static int main_(int argc, char **argv) { #ifndef PANTHEIOS_USE_WIDE_STRINGS pantheios::log_DEBUG("main_(", pantheios::args(argc, argv), ")"); #endif { unsigned flags = PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE; int res1 = pantheios_be_file_setFilePath(PSTR("test-%T-%D.log"), flags, flags, PANTHEIOS_BEID_LOCAL); pantheios_be_file_flush(PANTHEIOS_BEID_LOCAL); pantheios::log_NOTICE(PSTR("stmt 1")); } #ifndef PANTHEIOS_USE_WIDE_STRINGS { pantheios::log_NOTICE("stmt 1"); unsigned flags = PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE; int res1 = pantheios_be_file_setFilePath(FILENAME_LOCAL, flags, flags, PANTHEIOS_BEID_LOCAL); pantheios::log_NOTICE("stmt 2"); pantheios::log_NOTICE("stmt 3"); int res2 = pantheios_be_file_setFilePath(FILENAME_REMOTE, flags, flags, PANTHEIOS_BEID_REMOTE); pantheios::log_NOTICE("stmt 4"); pantheios::log_NOTICE("stmt 5"); pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_LOCAL); pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_REMOTE); pantheios::log_NOTICE("stmt 6"); pantheios::log_NOTICE("stmt 7"); file_lines_t local_lines(FILENAME_LOCAL); file_lines_t remote_lines(FILENAME_REMOTE); const size_t numLocal = local_lines.size(); const size_t numRemote = remote_lines.size(); STLSOFT_ASSERT(4 == numLocal); STLSOFT_ASSERT(2 == numRemote); fs_traits_t::delete_file(FILENAME_LOCAL); fs_traits_t::get_last_error(); fs_traits_t::delete_file(FILENAME_REMOTE); fs_traits_t::get_last_error(); STLSOFT_SUPPRESS_UNUSED(res1); STLSOFT_SUPPRESS_UNUSED(res2); } #endif pantheios::log_DEBUG(PSTR("exiting main_()")); return EXIT_SUCCESS; }
static int main_(int /* argc */, char** /*argv*/) { pantheios_be_file_setFilePath("normal.log", 0, 0, WG_LOG_FILE_ID); pantheios_be_file_setFilePath("error.log", 0, 0, WG_LOG_FILE_ERROR_ID); pantheios::log_WARNING("hello there all of you"); pantheios::log_NOTICE("hello there console and main log"); pantheios::log_DEBUG("hello there console"); return EXIT_SUCCESS; }
int log_to_file() { pantheios::log_NOTICE("log-1"); // save until log file set pantheios_be_file_setFilePath(PSTR("mylogfile"), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BEID_LOCAL); // sets log file; write "log-1" stmt pantheios::log_NOTICE("log-2"); // write "log-2" stmt pantheios_be_file_setFilePath(NULL); // close "mylogfile" pantheios::log_NOTICE("log-3"); // save until log file set pantheios_be_file_setFilePath(PSTR("mylogfile2"), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BEID_LOCAL); // sets log file; write "log-3" stmt pantheios::log_NOTICE("log-4"); // write "log-4" stmt return 2; } // closes "mylogfile2" during program closedown
int main(int argc, char **argv) { try { #ifndef PANTHEIOS_USE_WIDE_STRINGS pantheios::log_DEBUG("main(", pantheios::args(argc, argv), ")"); #else /* ? !PANTHEIOS_USE_WIDE_STRINGS */ STLSOFT_SUPPRESS_UNUSED(argc); STLSOFT_SUPPRESS_UNUSED(argv); #endif /* !PANTHEIOS_USE_WIDE_STRINGS */ pantheios::log_NOTICE(PSTR("stmt 1")); // Set the file name for the local back-end, truncating the // file's existing contents, if any. pantheios_be_file_setFilePath(PSTR("log.local"), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BEID_LOCAL); pantheios::log_NOTICE(PSTR("stmt 2")); // Set the file name for the remote back-end. pantheios_be_file_setFilePath(PSTR("log.remote"), PANTHEIOS_BEID_REMOTE); pantheios::log_NOTICE(PSTR("stmt 3")); // Set the file name for all back-ends. pantheios_be_file_setFilePath(PSTR("log.all")); pantheios::log_NOTICE(PSTR("stmt 4")); pantheios::log_DEBUG(PSTR("exiting main()")); return EXIT_SUCCESS; } catch(std::bad_alloc&) { pantheios::log(pantheios::alert, PSTR("out of memory")); } catch(std::exception& x) { pantheios::log_CRITICAL(PSTR("Exception: "), pantheios::exception(x)); } catch(...) { pantheios::logputs(pantheios::emergency, PSTR("Unexpected unknown error")); } return EXIT_FAILURE; }
static void test_ROLL_ON_ENTRIES() { // Create a file, with rolling quantum of unsigned flags = 0 | PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE | PANTHEIOS_BE_FILE_F_ROLL_ON_ENTRY_COUNT | 0; pantheios_be_file_setFilePath("rolling-log.test.remote", flags, flags, PANTHEIOS_BEID_REMOTE); const int NUM_ENTRIES = 104; { for(size_t i = 0; i < NUM_ENTRIES; ++i) { pantheios::log_NOTICE("stmt #", pantheios::integer(i)); }} pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_REMOTE); { for(size_t i = 0; i < NUM_ENTRIES; i += ENTRY_QUANTUM) { size_t index = i / ENTRY_QUANTUM; path_t path = "rolling-log.test.remote"; path /= pantheios::integer(index).c_str(); file_lines_t remote_lines(path); size_t numRemote = remote_lines.size(); STLSOFT_ASSERT(index < (NUM_ENTRIES / ENTRY_QUANTUM) ? ENTRY_QUANTUM == numRemote : (NUM_ENTRIES % ENTRY_QUANTUM) == numRemote); fs_traits_t::delete_file(path.c_str()); fs_traits_t::get_last_error(); }} }
int main() { /* Must initialise Pantheios, when using from C (and there are no C++ * compilation units in the link-unit). * * If this is not done, undefined behaviour will ensue ... */ if(pantheios_init() < 0) { return EXIT_FAILURE; } else { pantheios_logputs(PANTHEIOS_SEV_DEBUG, PANTHEIOS_LITERAL_STRING("debug")); pantheios_logputs(PANTHEIOS_SEV_INFORMATIONAL, PANTHEIOS_LITERAL_STRING("info")); pantheios_logputs(PANTHEIOS_SEV_NOTICE, PANTHEIOS_LITERAL_STRING("notice")); pantheios_logputs(PANTHEIOS_SEV_WARNING, PANTHEIOS_LITERAL_STRING("warn")); pantheios_be_file_setFilePath(PANTHEIOS_LITERAL_STRING("file-1.log"), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, 1); pantheios_logputs(PANTHEIOS_SEV_ERROR, PANTHEIOS_LITERAL_STRING("error")); pantheios_logputs(PANTHEIOS_SEV_CRITICAL, PANTHEIOS_LITERAL_STRING("critical")); pantheios_logputs(PANTHEIOS_SEV_ALERT, PANTHEIOS_LITERAL_STRING("alert")); pantheios_logputs(PANTHEIOS_SEV_EMERGENCY, PANTHEIOS_LITERAL_STRING("emergency")); pantheios_be_file_setFilePath(PANTHEIOS_LITERAL_STRING("file-5.log"), 0, 0, 5); /* Must uninitialise Pantheios. * * pantheios_uninit() must be called once for each successful (>=0) * invocation of pantheios_init(). */ pantheios_uninit(); return EXIT_SUCCESS; } }
static int main_(int argc, char** argv) { // This goes only to debugger #ifndef PANTHEIOS_USE_WIDE_STRINGS pantheios::log_NOTICE(PSTR("main("), pantheios::args(argc, argv), PSTR(")")); #else /* ? !PANTHEIOS_USE_WIDE_STRINGS */ STLSOFT_SUPPRESS_UNUSED(argc); STLSOFT_SUPPRESS_UNUSED(argv); #endif /* !PANTHEIOS_USE_WIDE_STRINGS */ // This goes to console and debugger pantheios_be_file_setFilePath("p4.log"); pantheios::log(pantheios::notice(beid_Syslog), PSTR("Isn't targeted multiplexing great?!")); pantheios::log(pantheios::notice(beid_Syslog), PSTR("Isn't targeted multiplexing great?!")); pantheios::log(pantheios::debug(beid_Syslog), PSTR("DEBUG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")); return EXIT_SUCCESS; }
int logging_init(const char* log_file_name) { try { pantheios_be_file_setFilePath(log_file_name); #ifdef DEBUG pantheios::log_DEBUG("pantheios logging_init()"); #endif return 1; } catch(std::bad_alloc&){ pantheios::log_ALERT("pantheios out of memory"); } catch(std::exception& x){ pantheios::log_CRITICAL("pantheios exception: ", x); } catch(...){ pantheios::puts(pantheios::emergency, "pantheios unknown error"); } return 2; };
static int main_(int /*argc*/, char** /*argv*/) { thread_handle_t threads[32]; pan::log_INFORMATIONAL(PSTR("main(): creating "), pan::integer(STLSOFT_NUM_ELEMENTS(threads)), PSTR(" threads")); { for(size_t i = 0; i < STLSOFT_NUM_ELEMENTS(threads); ++i) { void* arg = NULL; #if defined(PLATFORMSTL_OS_IS_UNIX) pthread_mutex_lock(&s_mx); if(0 != pthread_create(&threads[i], NULL, thread_proc, arg)) { pan::log_ALERT(PSTR("Failed to create thread "), pan::integer(i)); pthread_mutex_unlock(&s_mx); return EXIT_FAILURE; } else { pthread_detach(threads[i]); ++s_activeThreads; } pthread_mutex_unlock(&s_mx); #elif defined(PLATFORMSTL_OS_IS_WINDOWS) // NOTE: We are calling the Windows API function CreateThread() // directly, rather than going through beginthreadex() (or // equivalent), which is not the correct thing to do in a real // program, as CRT resources can be leaked. // // We do it this way in this case simply for portability of the // test program DWORD threadId; threads[i] = CreateThread(NULL, 0, thread_proc, arg, 0, &threadId); if(NULL == threads[i]) { winstl::error_desc err; pan::log_ALERT(PSTR("Failed to create thread "), pan::integer(i), PSTR(": "), err); return EXIT_FAILURE; } #else /* ? OS */ # error Operating system not discriminated #endif /* 0 */ }} s_showNotices && pan::log_NOTICE(PSTR("main(): all "), pan::integer(STLSOFT_NUM_ELEMENTS(threads)), PSTR(" threads started")); platformstl::micro_sleep(SET_PATH_DELAY); s_showNotices && pan::log_NOTICE(PSTR("main(): setting log file path")); pantheios_be_file_setFilePath(LOG_FILE_NAME, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, 0); s_showNotices && pan::log_NOTICE(PSTR("main(): waiting for threads to complete; this could take several minutes")); #if defined(PLATFORMSTL_OS_IS_UNIX) for(;;) { pthread_mutex_lock(&s_mx); if(0 == s_activeThreads) { pthread_mutex_unlock(&s_mx); break; } else { pthread_cond_wait(&s_cv, &s_mx); } pthread_mutex_unlock(&s_mx); } #elif defined(PLATFORMSTL_OS_IS_WINDOWS) ::WaitForMultipleObjects(STLSOFT_NUM_ELEMENTS(threads), &threads[0], true, INFINITE); #else /* ? OS */ # error Operating system not discriminated #endif /* 0 */ s_showNotices && pan::log_NOTICE(PSTR("main(): all "), pan::integer(STLSOFT_NUM_ELEMENTS(threads)), PSTR(" threads completed")); pantheios_be_file_setFilePath(NULL); int retVal = EXIT_SUCCESS; lines_t lines(LOG_FILE_NAME); { for(size_t i = 0; i != lines.size(); ++i) { lines_t::value_type const& line = lines[i]; string_view_t scratch1; string_view_t scratch2; string_view_t prefix; string_view_t left; string_view_t middle; string_view_t right; if( !stlsoft::split(line, PSTR('|'), prefix, scratch1) || !stlsoft::split(scratch1, PSTR('|'), left, scratch2) || !stlsoft::split(scratch2, PSTR('|'), middle, right)) { pan::log_CRITICAL(PSTR("line does not have required format: ["), pan::integer(i), PSTR(": "), line, PSTR("]")); retVal = EXIT_FAILURE; } else { if(left != right) { pan::log_CRITICAL(PSTR("line prefix and suffix do not match: ["), pan::integer(i), PSTR(": "), line, PSTR("]")); retVal = EXIT_FAILURE; } } }} if(EXIT_SUCCESS == retVal) { s_showNotices && pan::log_NOTICE(PSTR("all lines logged to file correctly")); } else { pan::log_CRITICAL(PSTR("multi-threaded use of be.file has been defective; please report to the Pantheios project")); } return retVal; }