17 #ifndef EASYLOGGINGPP_H 18 #define EASYLOGGINGPP_H 21 #if __cplusplus >= 201103L 23 #endif // __cplusplus >= 201103L 24 #if (defined(__GNUC__)) 25 # define ELPP_COMPILER_GCC 1 27 # define ELPP_COMPILER_GCC 0 30 # define ELPP_GCC_VERSION (__GNUC__ * 10000 \ 31 + __GNUC_MINOR__ * 100 \ 32 + __GNUC_PATCHLEVEL__) 33 # if defined(__GXX_EXPERIMENTAL_CXX0X__) 39 # define ELPP_COMPILER_MSVC 1 41 # define ELPP_COMPILER_MSVC 0 43 #define ELPP_CRT_DBG_WARNINGS ELPP_COMPILER_MSVC 44 #if ELPP_COMPILER_MSVC 45 # if (_MSC_VER == 1600) 47 # elif(_MSC_VER >= 1700) 52 #if (defined(__clang__) && (__clang__ == 1)) 53 # define ELPP_COMPILER_CLANG 1 55 # define ELPP_COMPILER_CLANG 0 57 #if ELPP_COMPILER_CLANG 58 # if __has_include(<thread>) 60 # if !defined(__GLIBCXX__) || __GLIBCXX__ >= 20150426 61 # define ELPP_CLANG_SUPPORTS_THREAD 62 # endif // !defined(__GLIBCXX__) || __GLIBCXX__ >= 20150426 63 # endif // __has_include(<thread>) 65 #if (defined(__MINGW32__) || defined(__MINGW64__)) 70 #if (defined(__CYGWIN__) && (__CYGWIN__ == 1)) 71 # define ELPP_CYGWIN 1 73 # define ELPP_CYGWIN 0 75 #if (defined(__INTEL_COMPILER)) 76 # define ELPP_COMPILER_INTEL 1 78 # define ELPP_COMPILER_INTEL 0 82 #if (defined(_WIN32) || defined(_WIN64)) 83 # define ELPP_OS_WINDOWS 1 85 # define ELPP_OS_WINDOWS 0 88 #if (defined(__linux) || defined(__linux__)) 89 # define ELPP_OS_LINUX 1 91 # define ELPP_OS_LINUX 0 93 #if (defined(__APPLE__)) 94 # define ELPP_OS_MAC 1 96 # define ELPP_OS_MAC 0 98 #if (defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) 99 # define ELPP_OS_FREEBSD 1 101 # define ELPP_OS_FREEBSD 0 103 #if (defined(__OpenBSD__)) 104 # define ELPP_OS_OPENBSD 1 106 # define ELPP_OS_OPENBSD 0 108 #if (defined(__NetBSD__)) 109 # define ELPP_OS_NETBSD 1 111 # define ELPP_OS_NETBSD 0 114 # define ELPP_OS_SOLARIS 1 116 # define ELPP_OS_SOLARIS 0 119 # define ELPP_OS_AIX 1 121 # define ELPP_OS_AIX 0 123 #if (defined(__NetBSD__)) 124 # define ELPP_OS_NETBSD 1 126 # define ELPP_OS_NETBSD 0 128 #if (defined(__DragonFly__)) 129 # define ELPP_OS_DRAGONFLY 1 131 # define ELPP_OS_DRAGONFLY 0 134 #if ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_NETBSD || ELPP_OS_SOLARIS || ELPP_OS_AIX || ELPP_OS_DRAGONFLY || ELPP_OS_OPENBSD) && (!ELPP_OS_WINDOWS)) 135 # define ELPP_OS_UNIX 1 137 # define ELPP_OS_UNIX 0 139 #if (defined(__ANDROID__)) 140 # define ELPP_OS_ANDROID 1 142 # define ELPP_OS_ANDROID 0 145 #if !ELPP_OS_UNIX && !ELPP_OS_WINDOWS && ELPP_CYGWIN 147 # undef ELPP_OS_LINUX 148 # define ELPP_OS_UNIX 1 149 # define ELPP_OS_LINUX 1 150 #endif // !ELPP_OS_UNIX && !ELPP_OS_WINDOWS && ELPP_CYGWIN 151 #if !defined(ELPP_INTERNAL_DEBUGGING_OUT_INFO) 152 # define ELPP_INTERNAL_DEBUGGING_OUT_INFO std::cout 153 #endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT) 154 #if !defined(ELPP_INTERNAL_DEBUGGING_OUT_ERROR) 155 # define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr 156 #endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT) 157 #if !defined(ELPP_INTERNAL_DEBUGGING_ENDL) 158 # define ELPP_INTERNAL_DEBUGGING_ENDL std::endl 159 #endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT) 160 #if !defined(ELPP_INTERNAL_DEBUGGING_MSG) 161 # define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg 162 #endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT) 164 #if !defined(ELPP_DISABLE_ASSERT) 165 # if (defined(ELPP_DEBUG_ASSERT_FAILURE)) 166 # define ELPP_ASSERT(expr, msg) if (!(expr)) { \ 167 std::stringstream internalInfoStream; internalInfoStream << msg; \ 168 ELPP_INTERNAL_DEBUGGING_OUT_ERROR \ 169 << "EASYLOGGING++ ASSERTION FAILED (LINE: " << __LINE__ << ") [" #expr << "] WITH MESSAGE \"" \ 170 << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" << ELPP_INTERNAL_DEBUGGING_ENDL; base::utils::abort(1, \ 171 "ELPP Assertion failure, please define ELPP_DEBUG_ASSERT_FAILURE"); } 173 # define ELPP_ASSERT(expr, msg) if (!(expr)) { \ 174 std::stringstream internalInfoStream; internalInfoStream << msg; \ 175 ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ 176 << "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ 177 << __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ 178 << ELPP_INTERNAL_DEBUGGING_ENDL; } 179 # endif // (defined(ELPP_DEBUG_ASSERT_FAILURE)) 181 # define ELPP_ASSERT(x, y) 182 #endif //(!defined(ELPP_DISABLE_ASSERT) 183 #if ELPP_COMPILER_MSVC 184 # define ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \ 185 { char buff[256]; strerror_s(buff, 256, errno); \ 186 ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << buff << " [" << errno << "]";} (void)0 188 # define ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \ 189 ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << strerror(errno) << " [" << errno << "]"; (void)0 190 #endif // ELPP_COMPILER_MSVC 191 #if defined(ELPP_DEBUG_ERRORS) 192 # if !defined(ELPP_INTERNAL_ERROR) 193 # define ELPP_INTERNAL_ERROR(msg, pe) { \ 194 std::stringstream internalInfoStream; internalInfoStream << "<ERROR> " << msg; \ 195 ELPP_INTERNAL_DEBUGGING_OUT_ERROR \ 196 << "ERROR FROM EASYLOGGING++ (LINE: " << __LINE__ << ") " \ 197 << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << ELPP_INTERNAL_DEBUGGING_ENDL; \ 198 if (pe) { ELPP_INTERNAL_DEBUGGING_OUT_ERROR << " "; ELPP_INTERNAL_DEBUGGING_WRITE_PERROR; }} (void)0 201 # undef ELPP_INTERNAL_INFO 202 # define ELPP_INTERNAL_ERROR(msg, pe) 203 #endif // defined(ELPP_DEBUG_ERRORS) 204 #if (defined(ELPP_DEBUG_INFO)) 205 # if !(defined(ELPP_INTERNAL_INFO_LEVEL)) 206 # define ELPP_INTERNAL_INFO_LEVEL 9 207 # endif // !(defined(ELPP_INTERNAL_INFO_LEVEL)) 208 # if !defined(ELPP_INTERNAL_INFO) 209 # define ELPP_INTERNAL_INFO(lvl, msg) { if (lvl <= ELPP_INTERNAL_INFO_LEVEL) { \ 210 std::stringstream internalInfoStream; internalInfoStream << "<INFO> " << msg; \ 211 ELPP_INTERNAL_DEBUGGING_OUT_INFO << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) \ 212 << ELPP_INTERNAL_DEBUGGING_ENDL; }} 215 # undef ELPP_INTERNAL_INFO 216 # define ELPP_INTERNAL_INFO(lvl, msg) 217 #endif // (defined(ELPP_DEBUG_INFO)) 218 #if (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG)) 219 # if (ELPP_COMPILER_GCC && !ELPP_MINGW && !ELPP_OS_OPENBSD && !ELPP_OS_NETBSD && !ELPP_OS_ANDROID) 220 # define ELPP_STACKTRACE 1 222 # define ELPP_STACKTRACE 0 223 # ifdef EASYLOGGING_CC 224 # if ELPP_COMPILER_MSVC 225 # pragma message("Stack trace not available for this compiler") 227 # warning "Stack trace not available for this compiler"; 228 # endif // ELPP_COMPILER_MSVC 230 # endif // ELPP_COMPILER_GCC 232 # define ELPP_STACKTRACE 0 233 #endif // (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG)) 235 #define ELPP_UNUSED(x) (void)x 238 # define ELPP_LOG_PERMS S_IRUSR | S_IWUSR | S_IXUSR | S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IXOTH 239 #endif // ELPP_OS_UNIX 240 #if defined(ELPP_AS_DLL) && ELPP_COMPILER_MSVC 241 # if defined(ELPP_EXPORT_SYMBOLS) 242 # define ELPP_EXPORT __declspec(dllexport) 244 # define ELPP_EXPORT __declspec(dllimport) 245 # endif // defined(ELPP_EXPORT_SYMBOLS) 248 #endif // defined(ELPP_AS_DLL) && ELPP_COMPILER_MSVC 254 #if ELPP_CRT_DBG_WARNINGS 255 # define STRTOK(a, b, c) strtok_s(a, b, c) 256 # define STRERROR(a, b, c) strerror_s(a, b, c) 257 # define STRCAT(a, b, len) strcat_s(a, len, b) 258 # define STRCPY(a, b, len) strcpy_s(a, len, b) 260 # define STRTOK(a, b, c) strtok(a, b) 261 # define STRERROR(a, b, c) strerror(c) 262 # define STRCAT(a, b, len) strcat(a, b) 263 # define STRCPY(a, b, len) strcpy(a, b) 266 #if (ELPP_MINGW && !defined(ELPP_FORCE_USE_STD_THREAD)) 267 # define ELPP_USE_STD_THREADING 0 269 # if ((ELPP_COMPILER_CLANG && defined(ELPP_CLANG_SUPPORTS_THREAD)) || \ 270 (!ELPP_COMPILER_CLANG && defined(ELPP_CXX11)) || \ 271 defined(ELPP_FORCE_USE_STD_THREAD)) 272 # define ELPP_USE_STD_THREADING 1 274 # define ELPP_USE_STD_THREADING 0 278 #if ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702) 281 # define ELPP_FINAL final 282 #endif // ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702) 283 #if defined(ELPP_EXPERIMENTAL_ASYNC) 284 # define ELPP_ASYNC_LOGGING 1 286 # define ELPP_ASYNC_LOGGING 0 287 #endif // defined(ELPP_EXPERIMENTAL_ASYNC) 288 #if defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING 289 # define ELPP_THREADING_ENABLED 1 291 # define ELPP_THREADING_ENABLED 0 292 #endif // defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING 295 #if ELPP_COMPILER_MSVC // Visual C++ 296 # define ELPP_FUNC __FUNCSIG__ 297 #elif ELPP_COMPILER_GCC // GCC 298 # define ELPP_FUNC __PRETTY_FUNCTION__ 299 #elif ELPP_COMPILER_INTEL // Intel C++ 300 # define ELPP_FUNC __PRETTY_FUNCTION__ 301 #elif ELPP_COMPILER_CLANG // Clang++ 302 # define ELPP_FUNC __PRETTY_FUNCTION__ 304 # if defined(__func__) 305 # define ELPP_FUNC __func__ 307 # define ELPP_FUNC "" 308 # endif // defined(__func__) 309 #endif // defined(_MSC_VER) 310 #undef ELPP_VARIADIC_TEMPLATES_SUPPORTED 312 #define ELPP_VARIADIC_TEMPLATES_SUPPORTED \ 313 (ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800)) 315 #ifdef ELPP_DISABLE_LOGS 316 # define ELPP_LOGGING_ENABLED 0 318 # define ELPP_LOGGING_ENABLED 1 320 #if (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED)) 321 # define ELPP_DEBUG_LOG 1 323 # define ELPP_DEBUG_LOG 0 324 #endif // (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED)) 325 #if (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED)) 326 # define ELPP_INFO_LOG 1 328 # define ELPP_INFO_LOG 0 329 #endif // (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED)) 330 #if (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED)) 331 # define ELPP_WARNING_LOG 1 333 # define ELPP_WARNING_LOG 0 334 #endif // (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED)) 335 #if (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED)) 336 # define ELPP_ERROR_LOG 1 338 # define ELPP_ERROR_LOG 0 339 #endif // (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED)) 340 #if (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED)) 341 # define ELPP_FATAL_LOG 1 343 # define ELPP_FATAL_LOG 0 344 #endif // (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED)) 345 #if (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED)) 346 # define ELPP_TRACE_LOG 1 348 # define ELPP_TRACE_LOG 0 349 #endif // (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED)) 350 #if (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED)) 351 # define ELPP_VERBOSE_LOG 1 353 # define ELPP_VERBOSE_LOG 0 354 #endif // (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED)) 355 #if (!(ELPP_CXX0X || ELPP_CXX11)) 356 # error "C++0x (or higher) support not detected! (Is `-std=c++11' missing?)" 357 #endif // (!(ELPP_CXX0X || ELPP_CXX11)) 359 #if defined(ELPP_SYSLOG) 361 #endif // defined(ELPP_SYSLOG) 370 #if defined(ELPP_UNICODE) 374 # endif // ELPP_OS_WINDOWS 375 #endif // defined(ELPP_UNICODE) 378 # include <execinfo.h> 379 #endif // ELPP_STACKTRACE 381 # include <sys/system_properties.h> 382 #endif // ELPP_OS_ANDROID 384 # include <sys/stat.h> 385 # include <sys/time.h> 386 #elif ELPP_OS_WINDOWS 388 # include <windows.h> 389 # if defined(WIN32_LEAN_AND_MEAN) 390 # if defined(ELPP_WINSOCK2) 391 # include <winsock2.h> 393 # include <winsock.h> 394 # endif // defined(ELPP_WINSOCK2) 395 # endif // defined(WIN32_LEAN_AND_MEAN) 396 #endif // ELPP_OS_UNIX 400 #include <unordered_map> 402 #include <functional> 408 #include <type_traits> 409 #if ELPP_THREADING_ENABLED 410 # if ELPP_USE_STD_THREADING 415 # include <pthread.h> 416 # endif // ELPP_OS_UNIX 417 # endif // ELPP_USE_STD_THREADING 418 #endif // ELPP_THREADING_ENABLED 419 #if ELPP_ASYNC_LOGGING 420 # if defined(ELPP_NO_SLEEP_FOR) 422 # endif // defined(ELPP_NO_SLEEP_FOR) 425 # include <condition_variable> 426 #endif // ELPP_ASYNC_LOGGING 427 #if defined(ELPP_STL_LOGGING) 435 # if defined(ELPP_LOG_STD_ARRAY) 437 # endif // defined(ELPP_LOG_STD_ARRAY) 438 # if defined(ELPP_LOG_UNORDERED_SET) 439 # include <unordered_set> 440 # endif // defined(ELPP_UNORDERED_SET) 441 #endif // defined(ELPP_STL_LOGGING) 442 #if defined(ELPP_QT_LOGGING) 445 # include <QByteArray> 452 # include <QLinkedList> 454 # include <QMultiHash> 456 #endif // defined(ELPP_QT_LOGGING) 457 #if defined(ELPP_BOOST_LOGGING) 459 # include <boost/container/vector.hpp> 460 # include <boost/container/stable_vector.hpp> 461 # include <boost/container/list.hpp> 462 # include <boost/container/deque.hpp> 463 # include <boost/container/map.hpp> 464 # include <boost/container/flat_map.hpp> 465 # include <boost/container/set.hpp> 466 # include <boost/container/flat_set.hpp> 467 #endif // defined(ELPP_BOOST_LOGGING) 468 #if defined(ELPP_WXWIDGETS_LOGGING) 470 # include <wx/vector.h> 471 #endif // defined(ELPP_WXWIDGETS_LOGGING) 472 #if defined(ELPP_UTC_DATETIME) 473 # define elpptime_r gmtime_r 474 # define elpptime_s gmtime_s 475 # define elpptime gmtime 477 # define elpptime_r localtime_r 478 # define elpptime_s localtime_s 479 # define elpptime localtime 480 #endif // defined(ELPP_UTC_DATETIME) 485 class PerformanceTrackingData;
496 class PerformanceTracker;
503 #if ELPP_ASYNC_LOGGING 504 class AsyncLogDispatchCallback;
505 class AsyncDispatchWorker;
506 #endif // ELPP_ASYNC_LOGGING 507 class DefaultPerformanceTrackingCallback;
519 #if defined(ELPP_UNICODE) 520 # define ELPP_LITERAL(txt) L##txt 521 # define ELPP_STRLEN wcslen 522 # if defined ELPP_CUSTOM_COUT 523 # define ELPP_COUT ELPP_CUSTOM_COUT 525 # define ELPP_COUT std::wcout 526 # endif // defined ELPP_CUSTOM_COUT 533 # define ELPP_LITERAL(txt) txt 534 # define ELPP_STRLEN strlen 535 # if defined ELPP_CUSTOM_COUT 536 # define ELPP_COUT ELPP_CUSTOM_COUT 538 # define ELPP_COUT std::cout 539 # endif // defined ELPP_CUSTOM_COUT 545 #endif // defined(ELPP_UNICODE) 546 #if defined(ELPP_CUSTOM_COUT_LINE) 547 # define ELPP_COUT_LINE(logLine) ELPP_CUSTOM_COUT_LINE(logLine) 549 # define ELPP_COUT_LINE(logLine) logLine << std::flush 550 #endif // defined(ELPP_CUSTOM_COUT_LINE) 628 return static_cast<Level>(l);
748 static const char kFormatSpecifierCharValue =
'v';
749 static const char kFormatSpecifierChar =
'%';
750 static const unsigned int kMaxLogPerCounter = 100000;
751 static const unsigned int kMaxLogPerContainer = 100;
752 static const unsigned int kDefaultSubsecondPrecision = 3;
754 #ifdef ELPP_DEFAULT_LOGGER 755 static const char* kDefaultLoggerId = ELPP_DEFAULT_LOGGER;
757 static const char* kDefaultLoggerId =
"default";
760 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 761 #ifdef ELPP_DEFAULT_PERFORMANCE_LOGGER 762 static const char* kPerformanceLoggerId = ELPP_DEFAULT_PERFORMANCE_LOGGER;
764 static const char* kPerformanceLoggerId =
"performance";
765 #endif // ELPP_DEFAULT_PERFORMANCE_LOGGER 768 #if defined(ELPP_SYSLOG) 769 static const char* kSysLogLoggerId =
"syslog";
770 #endif // defined(ELPP_SYSLOG) 773 static const char* kFilePathSeperator =
"\\";
775 static const char* kFilePathSeperator =
"/";
776 #endif // ELPP_OS_WINDOWS 778 static const std::size_t kSourceFilenameMaxLength = 100;
779 static const std::size_t kSourceLineMaxLength = 10;
801 SIGABRT,
"SIGABRT",
"Abnormal termination",
802 "Program was abnormally terminated." 805 SIGFPE,
"SIGFPE",
"Erroneous arithmetic operation",
806 "Arithemetic operation issue such as division by zero or operation resulting in overflow." 809 SIGILL,
"SIGILL",
"Illegal instruction",
810 "Generally due to a corruption in the code or to an attempt to execute data." 813 SIGSEGV,
"SIGSEGV",
"Invalid access to memory",
814 "Program is trying to read an invalid (unallocated, deleted or corrupted) or inaccessible memory." 817 SIGINT,
"SIGINT",
"Interactive attention signal",
818 "Interruption generated (generally) by user or operating system." 826 static inline void defaultPreRollOutCallback(
const char*, std::size_t) {}
853 init(base::consts::kDefaultSubsecondPrecision);
864 void init(
int width);
871 template <
typename T>
883 template <
typename Enum>
887 template <
typename Enum>
891 template <
typename Enum>
896 template <
typename Enum>
898 *flag = base::utils::bitwise::Or<Enum>(e, *flag);
900 template <
typename Enum>
902 *flag = base::utils::bitwise::Not<Enum>(e, *flag);
904 template <
typename Enum>
906 return base::utils::bitwise::And<Enum>(e, flag) > 0x0;
909 namespace threading {
910 #if ELPP_THREADING_ENABLED 911 # if !ELPP_USE_STD_THREADING 918 pthread_mutexattr_t attr;
919 pthread_mutexattr_init(&attr);
920 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
921 pthread_mutex_init(&m_underlyingMutex, &attr);
922 pthread_mutexattr_destroy(&attr);
923 # elif ELPP_OS_WINDOWS 924 InitializeCriticalSection(&m_underlyingMutex);
925 # endif // ELPP_OS_UNIX 930 pthread_mutex_destroy(&m_underlyingMutex);
931 # elif ELPP_OS_WINDOWS 932 DeleteCriticalSection(&m_underlyingMutex);
933 # endif // ELPP_OS_UNIX 938 pthread_mutex_lock(&m_underlyingMutex);
939 # elif ELPP_OS_WINDOWS 940 EnterCriticalSection(&m_underlyingMutex);
941 # endif // ELPP_OS_UNIX 946 return (pthread_mutex_trylock(&m_underlyingMutex) == 0);
947 # elif ELPP_OS_WINDOWS 948 return TryEnterCriticalSection(&m_underlyingMutex);
949 # endif // ELPP_OS_UNIX 954 pthread_mutex_unlock(&m_underlyingMutex);
955 # elif ELPP_OS_WINDOWS 956 LeaveCriticalSection(&m_underlyingMutex);
957 # endif // ELPP_OS_UNIX 962 pthread_mutex_t m_underlyingMutex;
963 # elif ELPP_OS_WINDOWS 964 CRITICAL_SECTION m_underlyingMutex;
965 # endif // ELPP_OS_UNIX 968 template <
typename M>
987 typedef std::recursive_mutex
Mutex;
988 typedef std::lock_guard<base::threading::Mutex>
ScopedLock;
989 # endif // !ELPP_USE_STD_THREADING 996 inline void lock(
void) {}
997 inline bool try_lock(
void) {
1000 inline void unlock(
void) {}
1003 template <
typename Mutex>
1006 explicit NoScopedLock(
Mutex&) {
1008 virtual ~NoScopedLock(
void) {
1014 typedef base::threading::internal::NoMutex
Mutex;
1015 typedef base::threading::internal::NoScopedLock<base::threading::Mutex>
ScopedLock;
1016 #endif // ELPP_THREADING_ENABLED 1030 #if ELPP_THREADING_ENABLED 1031 # if !ELPP_USE_STD_THREADING 1034 std::stringstream ss;
1035 # if (ELPP_OS_WINDOWS) 1036 ss << GetCurrentThreadId();
1037 # endif // (ELPP_OS_WINDOWS) 1043 std::stringstream ss;
1044 char prev_fill = ss.fill(
' ');
1045 auto prev_flags = ss.flags(std::ios::hex);
1047 auto prev_width = ss.width(16);
1048 ss << std::this_thread::get_id();
1050 ss.flags(prev_flags);
1051 ss.width(prev_width);
1054 # endif // !ELPP_USE_STD_THREADING 1056 static inline std::string getCurrentThreadId(
void) {
1059 #endif // ELPP_THREADING_ENABLED 1072 static bool pathExists(
const char* path,
bool considerFile =
false);
1079 const char* seperator = base::consts::kFilePathSeperator);
1082 std::size_t limit = base::consts::kSourceFilenameMaxLength);
1085 std::size_t limit = base::consts::kSourceFilenameMaxLength,
1086 const char* seperator = base::consts::kFilePathSeperator);
1093 return c >=
'0' && c <=
'9';
1097 static bool wildCardMatch(
const char* str,
const char* pattern);
1132 #if defined(ELPP_UNICODE) 1135 #endif // defined(ELPP_UNICODE) 1142 static bool cStringEq(
const char* s1,
const char* s2);
1149 static bool contains(
const char* str,
char c);
1151 static char*
convertAndAddToBuff(std::size_t n,
int len,
char*
buf,
const char* bufLim,
bool zeroPadded =
true);
1152 static char*
addToBuff(
const char* str,
char*
buf,
const char* bufLim);
1153 static char*
clearBuff(
char buff[], std::size_t lim);
1163 static const char* getWindowsEnvironmentVariable(
const char* varname);
1168 #endif // ELPP_OS_WINDOWS 1175 #endif // ELPP_OS_ANDROID 1190 const char* alternativeBashCommand =
nullptr);
1224 static unsigned long long getTimeDifference(
const struct timeval& endTime,
const struct timeval& startTime,
1228 static struct ::tm*
buildTimeInfo(
struct timeval* currTime, struct ::tm* timeInfo);
1230 static char* parseFormat(
char*
buf, std::size_t bufSz,
const char* format,
const struct tm* tInfo,
1237 setArgs(0, static_cast<char**>(
nullptr));
1247 inline void setArgs(
int argc,
const char** argv) {
1248 setArgs(argc, const_cast<char**>(argv));
1251 void setArgs(
int argc,
char** argv);
1258 bool hasParam(
const char* paramKey)
const;
1260 bool empty(
void)
const;
1262 std::size_t
size(
void)
const;
1268 std::unordered_map<std::string, std::string> m_paramsWithValue;
1269 std::vector<std::string> m_params;
1277 template <
typename T_Ptr,
typename Container>
1299 for (std::size_t i = 0; i < m_list.size(); ++i) {
1300 if (m_list.at(i) != other.m_list.at(i)) {
1311 for (std::size_t i = 0; i < m_list.size(); ++i) {
1312 if (m_list.at(i) != other.m_list.at(i)) {
1334 return m_list.begin();
1339 return m_list.end();
1345 return m_list.cbegin();
1350 return m_list.cend();
1355 return m_list.empty();
1360 return m_list.size();
1392 template <
typename T_Ptr,
typename T_Key = const
char*>
1425 if (!this->
empty()) {
1426 for (
auto&& curr : this->
list()) {
1427 base::utils::safeDelete(curr.second);
1429 this->
list().clear();
1436 this->
list().insert(std::make_pair(uniqKey, ptr));
1441 T_Ptr* existing =
get(uniqKey);
1442 if (existing !=
nullptr) {
1443 this->
list().erase(uniqKey);
1444 base::utils::safeDelete(existing);
1449 T_Ptr*
get(
const T_Key& uniqKey) {
1451 return it == this->
list().end()
1468 template <
typename T_Ptr,
typename Pred>
1509 if (!this->
empty()) {
1510 for (
auto&& curr : this->
list()) {
1511 base::utils::safeDelete(curr);
1513 this->
list().clear();
1520 for (; iter != this->
end(); ++iter) {
1525 if (iter != this->
end() && *iter !=
nullptr) {
1526 this->
list().erase(iter);
1527 base::utils::safeDelete(*iter);
1533 this->
list().push_back(ptr);
1538 template <
typename T,
typename T2>
1539 T_Ptr*
get(
const T& arg1,
const T2 arg2) {
1541 if (iter != this->
list().
end() && *iter !=
nullptr) {
1548 virtual void deepCopy(
const AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>& sr) {
1549 for (
const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
1556 template <
typename T,
typename TPtr>
1558 if (mapT->find(
id) == mapT->end()) {
1559 mapT->insert(std::make_pair(
id, TPtr(
new T())));
1565 template <
typename T,
typename TPtr>
1567 if (mapT->find(
id) != mapT->end()) {
1572 template <
typename T,
typename TPtr>
1574 typename std::unordered_map<std::string, TPtr>::iterator iter = mapT->find(
id);
1575 if (iter != mapT->end()) {
1576 return static_cast<T*
>(iter->second.get());
1617 return m_userFormat;
1625 return m_dateTimeFormat;
1633 return base::utils::hasFlag(flag, m_flags);
1650 base::utils::addFlag(flag, &m_flags);
1674 return m_formatSpecifier;
1684 const char* m_formatSpecifier;
1714 return m_configurationType;
1843 return m_configurationFile;
1892 static inline bool isConfig(
const std::string& line);
1939 return m_configurations;
1956 std::unordered_map<Level, bool> m_enabledMap;
1957 std::unordered_map<Level, bool> m_toFileMap;
1958 std::unordered_map<Level, std::string> m_filenameMap;
1959 std::unordered_map<Level, bool> m_toStandardOutputMap;
1960 std::unordered_map<Level, base::LogFormat> m_logFormatMap;
1961 std::unordered_map<Level, base::SubsecondPrecision> m_subsecondPrecisionMap;
1962 std::unordered_map<Level, bool> m_performanceTrackingMap;
1963 std::unordered_map<Level, base::FileStreamPtr> m_fileStreamMap;
1964 std::unordered_map<Level, std::size_t> m_maxLogFileSizeMap;
1965 std::unordered_map<Level, std::size_t> m_logFlushThresholdMap;
1974 template <
typename Conf_T>
1975 inline Conf_T getConfigByVal(
Level level,
const std::unordered_map<Level, Conf_T>* confMap,
const char* confName) {
1977 return unsafeGetConfigByVal(level, confMap, confName);
1980 template <
typename Conf_T>
1981 inline Conf_T& getConfigByRef(
Level level, std::unordered_map<Level, Conf_T>* confMap,
const char* confName) {
1983 return unsafeGetConfigByRef(level, confMap, confName);
1986 template <
typename Conf_T>
1987 Conf_T unsafeGetConfigByVal(
Level level,
const std::unordered_map<Level, Conf_T>* confMap,
const char* confName) {
1989 typename std::unordered_map<Level, Conf_T>::const_iterator it = confMap->find(level);
1990 if (it == confMap->end()) {
1996 << std::endl <<
"Please ensure you have properly configured logger.",
false);
2003 template <
typename Conf_T>
2004 Conf_T& unsafeGetConfigByRef(
Level level, std::unordered_map<Level, Conf_T>* confMap,
const char* confName) {
2006 typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(level);
2007 if (it == confMap->end()) {
2013 << std::endl <<
"Please ensure you have properly configured logger.",
false);
2019 template <
typename Conf_T>
2020 void setValue(
Level level,
const Conf_T&
value, std::unordered_map<Level, Conf_T>* confMap,
2021 bool includeGlobalLevel =
true) {
2023 if (confMap->empty() && includeGlobalLevel) {
2028 typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(
Level::Global);
2029 if (it != confMap->end() && it->second ==
value) {
2033 it = confMap->find(level);
2034 if (it == confMap->end()) {
2036 confMap->insert(std::make_pair(level,
value));
2039 confMap->at(level) =
value;
2051 return unsafeValidateFileRolling(level, preRollOutCallback);
2070 m_filename(hitCounter.m_filename),
2071 m_lineNumber(hitCounter.m_lineNumber),
2072 m_hitCounts(hitCounter.m_hitCounts) {
2076 if (&hitCounter !=
this) {
2077 m_filename = hitCounter.m_filename;
2078 m_lineNumber = hitCounter.m_lineNumber;
2079 m_hitCounts = hitCounter.m_hitCounts;
2095 if (m_hitCounts >= base::consts::kMaxLogPerCounter) {
2096 m_hitCounts = (n >= 1 ? base::consts::kMaxLogPerCounter % n : 0);
2106 return m_lineNumber;
2124 return ((counter !=
nullptr) &&
2125 (strcmp(counter->m_filename, m_filename) == 0) &&
2126 (counter->m_lineNumber == m_lineNumber));
2130 const char* m_filename;
2135 const char* m_filename;
2137 std::size_t m_hitCounts;
2157 return get(filename, lineNumber);
2165 template <
typename T>
2166 class Callback :
protected base::threading::ThreadSafe {
2177 virtual void handle(
const T* handlePtr) = 0;
2185 return m_logMessage;
2188 return m_dispatchAction;
2208 std::unordered_map<std::string, std::unique_ptr<base::threading::Mutex>> m_fileLocks;
2221 LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {}
2228 bool m_termSupportsColor;
2243 base::utils::safeDelete(m_typedConfigurations);
2261 return m_parentApplicationName;
2269 return &m_configurations;
2273 return m_typedConfigurations;
2284 return ++m_unflushedCount.find(level)->second >= m_typedConfigurations->
logFlushThreshold(level);
2288 return m_logBuilder.get();
2296 return m_typedConfigurations->
enabled(level);
2299 #if ELPP_VARIADIC_TEMPLATES_SUPPORTED 2300 # define LOGGER_LEVEL_WRITERS_SIGNATURES(FUNCTION_NAME)\ 2301 template <typename T, typename... Args>\ 2302 inline void FUNCTION_NAME(const char*, const T&, const Args&...);\ 2303 template <typename T>\ 2304 inline void FUNCTION_NAME(const T&); 2306 template <
typename T,
typename...
Args>
2307 inline void verbose(
int,
const char*,
const T&,
const Args&...);
2309 template <
typename T>
2310 inline void verbose(
int,
const T&);
2312 LOGGER_LEVEL_WRITERS_SIGNATURES(
info)
2313 LOGGER_LEVEL_WRITERS_SIGNATURES(debug)
2314 LOGGER_LEVEL_WRITERS_SIGNATURES(warn)
2315 LOGGER_LEVEL_WRITERS_SIGNATURES(
error)
2316 LOGGER_LEVEL_WRITERS_SIGNATURES(fatal)
2317 LOGGER_LEVEL_WRITERS_SIGNATURES(trace)
2318 # undef LOGGER_LEVEL_WRITERS_SIGNATURES 2319 #endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED 2325 bool m_isConfigured;
2327 std::unordered_map<Level, unsigned int> m_unflushedCount;
2345 #if ELPP_VARIADIC_TEMPLATES_SUPPORTED 2346 template <
typename T,
typename...
Args>
2347 void log_(
Level,
int,
const char*,
const T&,
const Args&...);
2349 template <
typename T>
2350 inline void log_(
Level,
int,
const T&);
2352 template <
typename T,
typename...
Args>
2355 template <
typename T>
2357 #endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED 2359 void initUnflushedCount(
void);
2365 void resolveLoggerFormatSpec(
void)
const;
2379 m_defaultConfigurations.
setFromBase(const_cast<Configurations*>(&configurations));
2383 return &m_defaultConfigurations;
2388 template <
typename T>
2390 return base::utils::Utils::installCallback<T, base::type::LoggerRegistrationCallbackPtr>(id,
2391 &m_loggerRegistrationCallbacks);
2394 template <
typename T>
2396 base::utils::Utils::uninstallCallback<T, base::type::LoggerRegistrationCallbackPtr>(id, &m_loggerRegistrationCallbacks);
2399 template <
typename T>
2401 return base::utils::Utils::callback<T, base::type::LoggerRegistrationCallbackPtr>(id, &m_loggerRegistrationCallbacks);
2407 return get(id,
false) !=
nullptr;
2416 return &m_logStreamsReference;
2426 m_defaultLogBuilder = logBuilderPtr;
2433 std::unordered_map<std::string, base::type::LoggerRegistrationCallbackPtr> m_loggerRegistrationCallbacks;
2436 void unsafeFlushAll(
void);
2452 m_categories.clear();
2453 m_cached_allowed_categories.clear();
2461 void setCategories(
const char* categories,
bool clear =
true);
2471 inline const std::unordered_map<std::string, base::type::VerboseLevel>&
modules(
void)
const {
2483 m_filenameCommonPrefix = prefix;
2487 return m_filenameCommonPrefix;
2493 std::unordered_map<std::string, base::type::VerboseLevel> m_modules;
2494 std::vector<std::pair<std::string, Level>> m_categories;
2495 std::map<std::string, int> m_cached_allowed_categories;
2520 return m_verboseLevel;
2538 #if ELPP_ASYNC_LOGGING 2539 class AsyncLogItem {
2542 : m_logMessage(logMessage), m_dispatchData(data), m_logLine(logLine) {}
2543 virtual ~AsyncLogItem() {}
2545 return &m_logMessage;
2547 inline LogDispatchData* data(
void) {
2548 return &m_dispatchData;
2555 LogDispatchData m_dispatchData;
2558 class AsyncLogQueue :
public base::threading::ThreadSafe {
2560 virtual ~AsyncLogQueue() {
2564 inline AsyncLogItem next(
void) {
2566 AsyncLogItem result = m_queue.front();
2571 inline void push(
const AsyncLogItem& item) {
2575 inline void pop(
void) {
2579 inline AsyncLogItem front(
void) {
2581 return m_queue.front();
2583 inline bool empty(
void) {
2585 return m_queue.empty();
2588 std::queue<AsyncLogItem> m_queue;
2592 virtual ~IWorker() {}
2593 virtual void start() = 0;
2595 #endif // ELPP_ASYNC_LOGGING 2596 class Storage : base::NoCopy,
public base::threading::ThreadSafe {
2599 #if ELPP_ASYNC_LOGGING 2603 #endif // ELPP_ASYNC_LOGGING 2620 return m_registeredHitCounters;
2624 return m_registeredLoggers;
2631 #if ELPP_ASYNC_LOGGING 2632 inline base::AsyncLogQueue* asyncLogQueue(
void)
const {
2633 return m_asyncLogQueue;
2635 #endif // ELPP_ASYNC_LOGGING 2638 return &m_commandLineArgs;
2642 base::utils::addFlag(flag, &m_flags);
2646 base::utils::removeFlag(flag, &m_flags);
2650 return base::utils::hasFlag(flag, m_flags);
2662 m_preRollOutCallback = callback;
2666 m_preRollOutCallback = base::defaultPreRollOutCallback;
2670 return m_preRollOutCallback;
2678 return &m_customFormatSpecifiers;
2682 return m_customFormatSpecifiersLock;
2686 m_loggingLevel = level;
2689 template <
typename T>
2691 return base::utils::Utils::installCallback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
2694 template <
typename T>
2696 base::utils::Utils::uninstallCallback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
2698 template <
typename T>
2700 return base::utils::Utils::callback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
2703 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2704 template <
typename T>
2705 inline bool installPerformanceTrackingCallback(
const std::string&
id) {
2706 return base::utils::Utils::installCallback<T, base::type::PerformanceTrackingCallbackPtr>(id,
2707 &m_performanceTrackingCallbacks);
2710 template <
typename T>
2711 inline void uninstallPerformanceTrackingCallback(
const std::string&
id) {
2712 base::utils::Utils::uninstallCallback<T, base::type::PerformanceTrackingCallbackPtr>(id,
2713 &m_performanceTrackingCallbacks);
2716 template <
typename T>
2717 inline T* performanceTrackingCallback(
const std::string&
id) {
2718 return base::utils::Utils::callback<T, base::type::PerformanceTrackingCallbackPtr>(id, &m_performanceTrackingCallbacks);
2720 #endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2724 if (
name.empty())
return;
2726 m_threadNames[base::threading::getCurrentThreadId()] =
name;
2731 std::unordered_map<std::string, std::string>::const_iterator it = m_threadNames.find(threadId);
2732 if (it == m_threadNames.end()) {
2745 #if ELPP_ASYNC_LOGGING 2746 base::AsyncLogQueue* m_asyncLogQueue;
2747 base::IWorker* m_asyncDispatchWorker;
2748 #endif // ELPP_ASYNC_LOGGING 2751 std::unordered_map<std::string, base::type::LogDispatchCallbackPtr> m_logDispatchCallbacks;
2752 std::unordered_map<std::string, base::type::PerformanceTrackingCallbackPtr> m_performanceTrackingCallbacks;
2753 std::unordered_map<std::string, std::string> m_threadNames;
2754 std::vector<CustomFormatSpecifier> m_customFormatSpecifiers;
2757 Level m_loggingLevel;
2767 void setApplicationArguments(
int argc,
char** argv);
2769 inline void setApplicationArguments(
int argc,
const char** argv) {
2770 setApplicationArguments(argc, const_cast<char**>(argv));
2774 #define ELPP el::base::Storage::getELPP() 2782 #if ELPP_ASYNC_LOGGING 2789 AsyncDispatchWorker();
2790 virtual ~AsyncDispatchWorker();
2793 void emptyQueue(
void);
2794 virtual void start(
void);
2795 void handle(AsyncLogItem* logItem);
2798 void setContinueRunning(
bool value) {
2800 m_continueRunning =
value;
2803 bool continueRunning(
void)
const {
2804 return m_continueRunning;
2807 std::condition_variable cv;
2808 bool m_continueRunning;
2811 #endif // ELPP_ASYNC_LOGGING 2823 m_logMessage(logMessage),
2824 m_dispatchAction(
std::
move(dispatchAction)) {
2834 #if defined(ELPP_STL_LOGGING) 2835 namespace workarounds {
2843 template <
typename T,
typename Container>
2844 class IterableContainer {
2846 typedef typename Container::iterator iterator;
2847 typedef typename Container::const_iterator const_iterator;
2848 IterableContainer(
void) {}
2849 virtual ~IterableContainer(
void) {}
2850 iterator begin(
void) {
2851 return getContainer().begin();
2853 iterator end(
void) {
2854 return getContainer().end();
2857 virtual Container& getContainer(
void) = 0;
2860 template<
typename T,
typename Container = std::vector<T>,
typename Comparator = std::less<
typename Container::value_type>>
2861 class IterablePriorityQueue :
public IterableContainer<T, Container>,
2862 public std::priority_queue<T, Container, Comparator> {
2864 IterablePriorityQueue(std::priority_queue<T, Container, Comparator> queue_) {
2865 std::size_t count_ = 0;
2866 while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) {
2867 this->push(queue_.top());
2872 inline Container& getContainer(
void) {
2877 template<
typename T,
typename Container = std::deque<T>>
2878 class IterableQueue :
public IterableContainer<T, Container>,
public std::queue<T, Container> {
2880 IterableQueue(std::queue<T, Container> queue_) {
2881 std::size_t count_ = 0;
2882 while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) {
2883 this->push(queue_.front());
2888 inline Container& getContainer(
void) {
2893 template<
typename T,
typename Container = std::deque<T>>
2894 class IterableStack :
public IterableContainer<T, Container>,
public std::stack<T, Container> {
2896 IterableStack(std::stack<T, Container> stack_) {
2897 std::size_t count_ = 0;
2898 while (++count_ < base::consts::kMaxLogPerContainer && !stack_.empty()) {
2899 this->push(stack_.top());
2904 inline Container& getContainer(
void) {
2909 #endif // defined(ELPP_STL_LOGGING) 2916 # define ELPP_SIMPLE_LOG(LOG_TYPE)\ 2917 MessageBuilder& operator<<(LOG_TYPE msg) {\ 2918 m_logger->stream() << msg;\ 2919 if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {\ 2920 m_logger->stream() << " ";\ 2948 m_logger->stream() << OStreamMani;
2951 #define ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(temp) \ 2952 template <typename T> \ 2953 inline MessageBuilder& operator<<(const temp<T>& template_inst) { \ 2954 return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ 2956 #define ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(temp) \ 2957 template <typename T1, typename T2> \ 2958 inline MessageBuilder& operator<<(const temp<T1, T2>& template_inst) { \ 2959 return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ 2961 #define ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(temp) \ 2962 template <typename T1, typename T2, typename T3> \ 2963 inline MessageBuilder& operator<<(const temp<T1, T2, T3>& template_inst) { \ 2964 return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ 2966 #define ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(temp) \ 2967 template <typename T1, typename T2, typename T3, typename T4> \ 2968 inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4>& template_inst) { \ 2969 return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ 2971 #define ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(temp) \ 2972 template <typename T1, typename T2, typename T3, typename T4, typename T5> \ 2973 inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4, T5>& template_inst) { \ 2974 return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size()); \ 2977 #if defined(ELPP_STL_LOGGING) 2985 template <
class T,
class Container>
2986 inline MessageBuilder& operator<<(const std::queue<T, Container>& queue_) {
2987 base::workarounds::IterableQueue<T, Container> iterableQueue_ =
2988 static_cast<base::workarounds::IterableQueue<T, Container>
>(queue_);
2989 return writeIterator(iterableQueue_.begin(), iterableQueue_.end(), iterableQueue_.size());
2991 template <
class T,
class Container>
2992 inline MessageBuilder& operator<<(const std::stack<T, Container>& stack_) {
2993 base::workarounds::IterableStack<T, Container> iterableStack_ =
2994 static_cast<base::workarounds::IterableStack<T, Container>
>(stack_);
2995 return writeIterator(iterableStack_.begin(), iterableStack_.end(), iterableStack_.size());
2997 template <
class T,
class Container,
class Comparator>
2998 inline MessageBuilder& operator<<(const std::priority_queue<T, Container, Comparator>& priorityQueue_) {
2999 base::workarounds::IterablePriorityQueue<T, Container, Comparator> iterablePriorityQueue_ =
3000 static_cast<base::workarounds::IterablePriorityQueue<T, Container, Comparator>
>(priorityQueue_);
3001 return writeIterator(iterablePriorityQueue_.begin(), iterablePriorityQueue_.end(), iterablePriorityQueue_.size());
3003 template <
class First,
class Second>
3004 MessageBuilder& operator<<(const std::pair<First, Second>& pair_) {
3006 operator << (static_cast<First>(pair_.first));
3008 operator << (static_cast<Second>(pair_.second));
3012 template <std::
size_t Size>
3019 # if defined(ELPP_LOG_STD_ARRAY) 3020 template <
class T, std::
size_t Size>
3021 inline MessageBuilder& operator<<(const std::array<T, Size>& array) {
3022 return writeIterator(array.begin(), array.end(), array.size());
3024 # endif // defined(ELPP_LOG_STD_ARRAY) 3025 # if defined(ELPP_LOG_UNORDERED_MAP) 3028 # endif // defined(ELPP_LOG_UNORDERED_MAP) 3029 # if defined(ELPP_LOG_UNORDERED_SET) 3032 # endif // defined(ELPP_LOG_UNORDERED_SET) 3033 #endif // defined(ELPP_STL_LOGGING) 3034 #if defined(ELPP_QT_LOGGING) 3036 # if defined(ELPP_UNICODE) 3037 m_logger->stream() << msg.toStdWString();
3039 m_logger->stream() << msg.toStdString();
3040 # endif // defined(ELPP_UNICODE) 3050 # if defined(ELPP_UNICODE) 3051 m_logger->stream() << QString::number(msg).toStdWString();
3053 m_logger->stream() << QString::number(msg).toStdString();
3054 # endif // defined(ELPP_UNICODE) 3058 # if defined(ELPP_UNICODE) 3059 m_logger->stream() << QString::number(msg).toStdWString();
3061 m_logger->stream() << QString::number(msg).toStdString();
3062 # endif // defined(ELPP_UNICODE) 3066 m_logger->stream() << msg.toLatin1();
3070 m_logger->stream() << msg.latin1();
3079 template <
typename First,
typename Second>
3082 operator << (static_cast<First>(pair_.first));
3084 operator << (static_cast<Second>(pair_.second));
3088 template <
typename K,
typename V>
3091 QList<K> keys = map_.keys();
3092 typename QList<K>::const_iterator begin = keys.begin();
3093 typename QList<K>::const_iterator end = keys.end();
3094 int max_ =
static_cast<int>(base::consts::kMaxLogPerContainer);
3095 for (
int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) {
3097 operator << (static_cast<K>(*begin));
3099 operator << (static_cast<V>(map_.value(*begin)));
3101 m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator :
ELPP_LITERAL(
""));
3109 template <
typename K,
typename V>
3111 operator << (static_cast<QMap<K, V>>(map_));
3114 template <
typename K,
typename V>
3117 QList<K> keys = hash_.keys();
3118 typename QList<K>::const_iterator begin = keys.begin();
3119 typename QList<K>::const_iterator end = keys.end();
3120 int max_ =
static_cast<int>(base::consts::kMaxLogPerContainer);
3121 for (
int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) {
3123 operator << (static_cast<K>(*begin));
3125 operator << (static_cast<V>(hash_.value(*begin)));
3127 m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator :
ELPP_LITERAL(
""));
3135 template <
typename K,
typename V>
3136 inline MessageBuilder& operator<<(const QMultiHash<K, V>& multiHash_) {
3137 operator << (static_cast<QHash<K, V>>(multiHash_));
3140 #endif // defined(ELPP_QT_LOGGING) 3141 #if defined(ELPP_BOOST_LOGGING) 3150 #endif // defined(ELPP_BOOST_LOGGING) 3160 #define MAKE_CONTAINERELPP_FRIENDLY(ContainerType, SizeMethod, ElementInstance) \ 3161 el::base::type::ostream_t& operator<<(el::base::type::ostream_t& ss, const ContainerType& container) {\ 3162 const el::base::type::char_t* sep = ELPP->hasFlag(el::LoggingFlag::NewLineForContainer) ? \ 3163 ELPP_LITERAL("\n ") : ELPP_LITERAL(", ");\ 3164 ContainerType::const_iterator elem = container.begin();\ 3165 ContainerType::const_iterator endElem = container.end();\ 3166 std::size_t size_ = container.SizeMethod; \ 3167 ss << ELPP_LITERAL("[");\ 3168 for (std::size_t i = 0; elem != endElem && i < el::base::consts::kMaxLogPerContainer; ++i, ++elem) { \ 3169 ss << ElementInstance;\ 3170 ss << ((i < size_ - 1) ? sep : ELPP_LITERAL(""));\ 3172 if (elem != endElem) {\ 3173 ss << ELPP_LITERAL("...");\ 3175 ss << ELPP_LITERAL("]");\ 3178 #if defined(ELPP_WXWIDGETS_LOGGING) 3180 # define ELPP_WX_PTR_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), *(*elem)) 3181 # define ELPP_WX_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), (*elem)) 3182 # define ELPP_WX_HASH_MAP_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), \ 3183 ELPP_LITERAL("(") << elem->first << ELPP_LITERAL(", ") << elem->second << ELPP_LITERAL(")") 3185 # define ELPP_WX_PTR_ENABLED(ContainerType) 3186 # define ELPP_WX_ENABLED(ContainerType) 3187 # define ELPP_WX_HASH_MAP_ENABLED(ContainerType) 3188 #endif // defined(ELPP_WXWIDGETS_LOGGING) 3190 template <
class Class>
3192 #undef ELPP_SIMPLE_LOG 3193 #undef ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG 3194 #undef ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG 3195 #undef ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG 3196 #undef ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG 3197 #undef ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG 3202 template<
class Iterator>
3203 MessageBuilder& writeIterator(Iterator begin_, Iterator end_, std::size_t size_) {
3205 for (std::size_t i = 0; begin_ != end_ && i < base::consts::kMaxLogPerContainer; ++i, ++begin_) {
3207 m_logger->stream() << ((i < size_ - 1) ? m_containerLogSeperator :
ELPP_LITERAL(
""));
3209 if (begin_ != end_) {
3214 m_logger->stream() <<
" ";
3229 template <
typename T>
3257 template <
typename T>
3260 #if ELPP_LOGGING_ENABLED 3264 #endif // ELPP_LOGGING_ENABLED 3268 template <
typename T>
3271 #if ELPP_LOGGING_ENABLED 3275 #endif // ELPP_LOGGING_ENABLED 3280 #if ELPP_LOGGING_ENABLED 3284 #endif // ELPP_LOGGING_ENABLED 3319 base::
Writer(level, file, line, func, dispatchAction, verboseLevel) {
3326 #if ELPP_VARIADIC_TEMPLATES_SUPPORTED 3327 template <
typename T,
typename...
Args>
3328 void Logger::log_(
Level level,
int vlevel,
const char* s,
const T&
value,
const Args&... args) {
3329 base::MessageBuilder b;
3332 if (*s == base::consts::kFormatSpecifierChar) {
3333 if (*(s + 1) == base::consts::kFormatSpecifierChar) {
3336 if (*(s + 1) == base::consts::kFormatSpecifierCharValue) {
3339 log_(level, vlevel, ++s, args...);
3346 ELPP_INTERNAL_ERROR(
"Too many arguments provided. Unable to handle. Please provide more format specifiers",
false);
3348 template <
typename T>
3349 void Logger::log_(
Level level,
int vlevel,
const T& log) {
3351 if (
ELPP->vRegistry()->allowed(vlevel, __FILE__)) {
3359 base::Writer(level,
"FILE", 0,
"FUNCTION").construct(
this,
false) <<
log;
3362 template <
typename T,
typename...
Args>
3365 log_(level, 0, s,
value, args...);
3367 template <
typename T>
3370 log_(level, 0,
log);
3372 # if ELPP_VERBOSE_LOG 3373 template <
typename T,
typename...
Args>
3378 template <
typename T>
3384 template <
typename T,
typename...
Args>
3388 template <
typename T>
3392 # endif // ELPP_VERBOSE_LOG 3393 # define LOGGER_LEVEL_WRITERS(FUNCTION_NAME, LOG_LEVEL)\ 3394 template <typename T, typename... Args>\ 3395 inline void Logger::FUNCTION_NAME(const char* s, const T& value, const Args&... args) {\ 3396 log(LOG_LEVEL, s, value, args...);\ 3398 template <typename T>\ 3399 inline void Logger::FUNCTION_NAME(const T& value) {\ 3400 log(LOG_LEVEL, value);\ 3402 # define LOGGER_LEVEL_WRITERS_DISABLED(FUNCTION_NAME, LOG_LEVEL)\ 3403 template <typename T, typename... Args>\ 3404 inline void Logger::FUNCTION_NAME(const char*, const T&, const Args&...) {\ 3407 template <typename T>\ 3408 inline void Logger::FUNCTION_NAME(const T&) {\ 3416 # endif // ELPP_INFO_LOG 3421 # endif // ELPP_DEBUG_LOG 3422 # if ELPP_WARNING_LOG 3426 # endif // ELPP_WARNING_LOG 3431 # endif // ELPP_ERROR_LOG 3436 # endif // ELPP_FATAL_LOG 3441 # endif // ELPP_TRACE_LOG 3442 # undef LOGGER_LEVEL_WRITERS 3443 # undef LOGGER_LEVEL_WRITERS_DISABLED 3444 #endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED 3445 #if ELPP_COMPILER_MSVC 3446 # define ELPP_VARIADIC_FUNC_MSVC(variadicFunction, variadicArgs) variadicFunction variadicArgs 3447 # define ELPP_VARIADIC_FUNC_MSVC_RUN(variadicFunction, ...) ELPP_VARIADIC_FUNC_MSVC(variadicFunction, (__VA_ARGS__)) 3448 # define el_getVALength(...) ELPP_VARIADIC_FUNC_MSVC_RUN(el_resolveVALength, 0, ## __VA_ARGS__,\ 3449 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) 3451 # if ELPP_COMPILER_CLANG 3452 # define el_getVALength(...) el_resolveVALength(0, __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) 3454 # define el_getVALength(...) el_resolveVALength(0, ## __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) 3455 # endif // ELPP_COMPILER_CLANG 3456 #endif // ELPP_COMPILER_MSVC 3457 #define el_resolveVALength(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N 3458 #define ELPP_WRITE_LOG(writer, level, dispatchAction, ...) \ 3459 writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 3460 #define ELPP_WRITE_LOG_IF(writer, condition, level, dispatchAction, ...) if (condition) \ 3461 writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 3462 #define ELPP_WRITE_LOG_EVERY_N(writer, occasion, level, dispatchAction, ...) \ 3463 ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion) && \ 3464 writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 3465 #define ELPP_WRITE_LOG_AFTER_N(writer, n, level, dispatchAction, ...) \ 3466 ELPP->validateAfterNCounter(__FILE__, __LINE__, n) && \ 3467 writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 3468 #define ELPP_WRITE_LOG_N_TIMES(writer, n, level, dispatchAction, ...) \ 3469 ELPP->validateNTimesCounter(__FILE__, __LINE__, n) && \ 3470 writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 3471 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 3472 class PerformanceTrackingData {
3475 Checkpoint = 1, Complete = 2
3478 explicit PerformanceTrackingData(DataType dataType) : m_performanceTracker(
nullptr),
3479 m_dataType(dataType), m_firstCheckpoint(
false), m_file(
""), m_line(0), m_func(
"") {}
3481 inline const struct timeval* startTime(
void)
const;
3482 inline const struct timeval* endTime(
void)
const;
3483 inline const struct timeval* lastCheckpointTime(
void)
const;
3484 inline const base::PerformanceTracker* performanceTracker(
void)
const {
3485 return m_performanceTracker;
3487 inline PerformanceTrackingData::DataType dataType(
void)
const {
3490 inline bool firstCheckpoint(
void)
const {
3491 return m_firstCheckpoint;
3494 return m_checkpointId;
3496 inline const char* file(
void)
const {
3502 inline const char* func(
void)
const {
3506 return &m_formattedTimeTaken;
3510 base::PerformanceTracker* m_performanceTracker;
3512 PerformanceTrackingData::DataType m_dataType;
3513 bool m_firstCheckpoint;
3518 inline void init(base::PerformanceTracker* performanceTracker,
bool firstCheckpoint =
false) {
3519 m_performanceTracker = performanceTracker;
3520 m_firstCheckpoint = firstCheckpoint;
3523 friend class el::base::PerformanceTracker;
3528 class PerformanceTracker :
public base::threading::ThreadSafe,
public Loggable {
3533 bool scopedLog =
true,
Level level = base::consts::kPerformanceTrackerDefaultLevel);
3535 PerformanceTracker(
const PerformanceTracker& t) :
3536 m_blockName(t.m_blockName), m_timestampUnit(t.m_timestampUnit), m_loggerId(t.m_loggerId), m_scopedLog(t.m_scopedLog),
3537 m_level(t.m_level), m_hasChecked(t.m_hasChecked), m_lastCheckpointId(t.m_lastCheckpointId), m_enabled(t.m_enabled),
3538 m_startTime(t.m_startTime), m_endTime(t.m_endTime), m_lastCheckpointTime(t.m_lastCheckpointTime) {
3540 virtual ~PerformanceTracker(
void);
3544 const char* func =
"");
3545 inline Level level(
void)
const {
3557 struct timeval m_startTime, m_endTime, m_lastCheckpointTime;
3559 PerformanceTracker(
void);
3561 friend class el::PerformanceTrackingData;
3562 friend class base::DefaultPerformanceTrackingCallback;
3565 return getFormattedTimeTaken(m_startTime);
3571 os << getFormattedTimeTaken();
3574 class DefaultPerformanceTrackingCallback :
public PerformanceTrackingCallback {
3576 void handle(
const PerformanceTrackingData* data) {
3579 if (m_data->dataType() == PerformanceTrackingData::DataType::Complete) {
3584 if (!m_data->checkpointId().empty()) {
3588 *m_data->performanceTracker();
3590 && m_data->performanceTracker()->m_hasChecked) {
3592 if (m_data->performanceTracker()->m_lastCheckpointId.empty()) {
3595 ss <<
ELPP_LITERAL(
"checkpoint '") << m_data->performanceTracker()->m_lastCheckpointId.c_str() <<
ELPP_LITERAL(
"'");
3602 el::base::Writer(m_data->performanceTracker()->level(), m_data->file(), m_data->line(), m_data->func()).construct(1,
3603 m_data->loggerId().c_str()) << ss.str();
3606 const PerformanceTrackingData* m_data;
3609 inline const std::string* PerformanceTrackingData::blockName()
const {
3610 return const_cast<const std::string*
>(&m_performanceTracker->m_blockName);
3612 inline const struct timeval* PerformanceTrackingData::startTime()
const {
3613 return const_cast<const struct timeval*
>(&m_performanceTracker->m_startTime);
3615 inline const struct timeval* PerformanceTrackingData::endTime()
const {
3616 return const_cast<const struct timeval*
>(&m_performanceTracker->m_endTime);
3618 inline const struct timeval* PerformanceTrackingData::lastCheckpointTime()
const {
3619 return const_cast<const struct timeval*
>(&m_performanceTracker->m_lastCheckpointTime);
3621 inline const std::string& PerformanceTrackingData::loggerId(
void)
const {
3622 return m_performanceTracker->m_loggerId;
3624 #endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 3628 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG) 3631 static const unsigned int kMaxStack = 64;
3632 static const unsigned int kStackStart = 2;
3633 class StackTraceEntry {
3637 StackTraceEntry(std::size_t index,
const std::string& loc) :
3641 std::size_t m_index;
3646 friend std::ostream&
operator<<(std::ostream& ss,
const StackTraceEntry& si);
3649 StackTraceEntry(
void);
3656 virtual ~StackTrace(
void) {
3659 inline std::vector<StackTraceEntry>& getLatestStack(
void) {
3663 friend std::ostream&
operator<<(std::ostream& os,
const StackTrace& st);
3666 std::vector<StackTraceEntry> m_stack;
3668 void generateNew(
void);
3673 typedef void (*Handler)(int);
3677 setHandler(cHandler);
3679 void setHandler(
const Handler& cHandler);
3689 #endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG) 3693 #define MAKE_LOGGABLE(ClassType, ClassInstance, OutputStreamInstance) \ 3694 el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance) 3695 class SysLogInitializer {
3699 #if defined(ELPP_SYSLOG) 3700 openlog(processIdent, options, facility);
3705 #endif // defined(ELPP_SYSLOG) 3708 #if defined(ELPP_SYSLOG) 3710 #endif // defined(ELPP_SYSLOG) 3713 #define ELPP_INITIALIZE_SYSLOG(id, opt, fac) el::SysLogInitializer elSyslogInit(id, opt, fac) 3714 class Helpers : base::StaticClass {
3726 static inline void setArgs(
int argc,
char** argv) {
3727 ELPP->setApplicationArguments(argc, argv);
3730 static inline void setArgs(
int argc,
const char** argv) {
3731 ELPP->setApplicationArguments(argc, const_cast<char**>(argv));
3738 return ELPP->getThreadName(base::threading::getCurrentThreadId());
3740 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG) 3741 static inline void setCrashHandler(
const el::base::debug::CrashHandler::Handler& crashHandler) {
3749 static void crashAbort(
int sig,
const char* sourceFile =
"",
unsigned int long line = 0);
3755 static void logCrashReason(
int sig,
bool stackTraceIfAvailable =
false,
3756 Level level =
Level::Fatal,
const char* logger = base::consts::kDefaultLoggerId);
3757 #endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG) 3761 ELPP->setPreRollOutCallback(callback);
3765 ELPP->unsetPreRollOutCallback();
3768 template <
typename T>
3770 return ELPP->installLogDispatchCallback<
T>(id);
3773 template <
typename T>
3775 ELPP->uninstallLogDispatchCallback<
T>(id);
3777 template <
typename T>
3779 return ELPP->logDispatchCallback<
T>(id);
3781 #if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 3782 template <
typename T>
3784 static inline bool installPerformanceTrackingCallback(
const std::string&
id) {
3785 return ELPP->installPerformanceTrackingCallback<
T>(id);
3788 template <
typename T>
3789 static inline void uninstallPerformanceTrackingCallback(
const std::string&
id) {
3790 ELPP->uninstallPerformanceTrackingCallback<
T>(id);
3792 template <
typename T>
3793 static inline T* performanceTrackingCallback(
const std::string&
id) {
3794 return ELPP->performanceTrackingCallback<
T>(id);
3796 #endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 3797 template <
typename T>
3801 ELPP->registeredLoggers()->get(el::base::consts::kDefaultLoggerId);
3802 if (logger ==
nullptr) {
3809 #if defined(ELPP_UNICODE) 3813 #endif // defined(ELPP_UNICODE) 3820 return ELPP->commandLineArgs();
3825 ELPP->m_customFormatSpecifiers.reserve(size);
3829 ELPP->installCustomFormatSpecifier(customFormatSpecifier);
3833 return ELPP->uninstallCustomFormatSpecifier(formatSpecifier);
3837 return ELPP->hasCustomFormatSpecifier(formatSpecifier);
3840 if (
ELPP ==
nullptr || logger ==
nullptr)
return;
3841 logger->m_typedConfigurations->validateFileRolling(level,
ELPP->preRollOutCallback());
3852 template <
typename T>
3854 return ELPP->registeredLoggers()->installLoggerRegistrationCallback<
T>(id);
3857 template <
typename T>
3859 ELPP->registeredLoggers()->uninstallLoggerRegistrationCallback<
T>(id);
3861 template <
typename T>
3863 return ELPP->registeredLoggers()->loggerRegistrationCallback<
T>(id);
3888 bool reconfigureExistingLoggers =
false);
3909 ELPP->addFlag(flag);
3913 ELPP->removeFlag(flag);
3917 return ELPP->hasFlag(flag);
3945 ELPP->setLoggingLevel(level);
3954 static void setCategories(
const char* categories,
bool clear =
true);
3976 #define VLOG_IS_ON(verboseLevel) (ELPP->vRegistry()->allowed(verboseLevel, __FILE__)) 3980 #undef TIMED_SCOPE_IF 3982 #undef TIMED_FUNC_IF 3983 #undef ELPP_MIN_UNIT 3984 #if defined(ELPP_PERFORMANCE_MICROSECONDS) 3985 # define ELPP_MIN_UNIT el::base::TimestampUnit::Microsecond 3987 # define ELPP_MIN_UNIT el::base::TimestampUnit::Millisecond 3988 #endif // (defined(ELPP_PERFORMANCE_MICROSECONDS)) 3996 #define TIMED_SCOPE_IF(obj, blockname, condition) el::base::type::PerformanceTrackerPtr obj( condition ? \ 3997 new el::base::PerformanceTracker(blockname, ELPP_MIN_UNIT) : nullptr ) 3998 #define TIMED_SCOPE(obj, blockname) TIMED_SCOPE_IF(obj, blockname, true) 3999 #define TIMED_BLOCK(obj, blockName) for (struct { int i; el::base::type::PerformanceTrackerPtr timer; } obj = { 0, \ 4000 el::base::type::PerformanceTrackerPtr(new el::base::PerformanceTracker(blockName, ELPP_MIN_UNIT)) }; obj.i < 1; ++obj.i) 4001 #define TIMED_FUNC_IF(obj,condition) TIMED_SCOPE_IF(obj, ELPP_FUNC, condition) 4008 #define TIMED_FUNC(obj) TIMED_SCOPE(obj, ELPP_FUNC) 4009 #undef PERFORMANCE_CHECKPOINT 4010 #undef PERFORMANCE_CHECKPOINT_WITH_ID 4011 #define PERFORMANCE_CHECKPOINT(obj) obj->checkpoint(std::string(), __FILE__, __LINE__, ELPP_FUNC) 4012 #define PERFORMANCE_CHECKPOINT_WITH_ID(obj, id) obj->checkpoint(id, __FILE__, __LINE__, ELPP_FUNC) 4014 #undef ELPP_COUNTER_POS 4015 #define ELPP_COUNTER (ELPP->hitCounters()->getCounter(__FILE__, __LINE__)) 4017 #define ELPP_COUNTER_POS (ELPP_COUNTER == nullptr ? -1 : ELPP_COUNTER->hitCounts()) 4042 #undef CINFO_EVERY_N 4043 #undef CWARNING_EVERY_N 4044 #undef CDEBUG_EVERY_N 4045 #undef CERROR_EVERY_N 4046 #undef CFATAL_EVERY_N 4047 #undef CTRACE_EVERY_N 4048 #undef CVERBOSE_EVERY_N 4049 #undef CINFO_AFTER_N 4050 #undef CWARNING_AFTER_N 4051 #undef CDEBUG_AFTER_N 4052 #undef CERROR_AFTER_N 4053 #undef CFATAL_AFTER_N 4054 #undef CTRACE_AFTER_N 4055 #undef CVERBOSE_AFTER_N 4056 #undef CINFO_N_TIMES 4057 #undef CWARNING_N_TIMES 4058 #undef CDEBUG_N_TIMES 4059 #undef CERROR_N_TIMES 4060 #undef CFATAL_N_TIMES 4061 #undef CTRACE_N_TIMES 4062 #undef CVERBOSE_N_TIMES 4065 # define CINFO(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__) 4067 # define CINFO(writer, dispatchAction, ...) el::base::NullWriter() 4068 #endif // ELPP_INFO_LOG 4069 #if ELPP_WARNING_LOG 4070 # define CWARNING(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__) 4072 # define CWARNING(writer, dispatchAction, ...) el::base::NullWriter() 4073 #endif // ELPP_WARNING_LOG 4075 # define CDEBUG(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__) 4077 # define CDEBUG(writer, dispatchAction, ...) el::base::NullWriter() 4078 #endif // ELPP_DEBUG_LOG 4080 # define CERROR(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__) 4082 # define CERROR(writer, dispatchAction, ...) el::base::NullWriter() 4083 #endif // ELPP_ERROR_LOG 4085 # define CFATAL(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__) 4087 # define CFATAL(writer, dispatchAction, ...) el::base::NullWriter() 4088 #endif // ELPP_FATAL_LOG 4090 # define CTRACE(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__) 4092 # define CTRACE(writer, dispatchAction, ...) el::base::NullWriter() 4093 #endif // ELPP_TRACE_LOG 4094 #if ELPP_VERBOSE_LOG 4095 # define CVERBOSE(writer, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel)) writer(\ 4096 el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 4098 # define CVERBOSE(writer, vlevel, dispatchAction, ...) el::base::NullWriter() 4099 #endif // ELPP_VERBOSE_LOG 4102 # define CINFO_IF(writer, condition_, dispatchAction, ...) \ 4103 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__) 4105 # define CINFO_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4106 #endif // ELPP_INFO_LOG 4107 #if ELPP_WARNING_LOG 4108 # define CWARNING_IF(writer, condition_, dispatchAction, ...)\ 4109 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__) 4111 # define CWARNING_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4112 #endif // ELPP_WARNING_LOG 4114 # define CDEBUG_IF(writer, condition_, dispatchAction, ...)\ 4115 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, dispatchAction, __VA_ARGS__) 4117 # define CDEBUG_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4118 #endif // ELPP_DEBUG_LOG 4120 # define CERROR_IF(writer, condition_, dispatchAction, ...)\ 4121 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, dispatchAction, __VA_ARGS__) 4123 # define CERROR_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4124 #endif // ELPP_ERROR_LOG 4126 # define CFATAL_IF(writer, condition_, dispatchAction, ...)\ 4127 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__) 4129 # define CFATAL_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4130 #endif // ELPP_FATAL_LOG 4132 # define CTRACE_IF(writer, condition_, dispatchAction, ...)\ 4133 ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, dispatchAction, __VA_ARGS__) 4135 # define CTRACE_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter() 4136 #endif // ELPP_TRACE_LOG 4137 #if ELPP_VERBOSE_LOG 4138 # define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel) && (condition_)) writer( \ 4139 el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__) 4141 # define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) el::base::NullWriter() 4142 #endif // ELPP_VERBOSE_LOG 4145 # define CINFO_EVERY_N(writer, occasion, dispatchAction, ...)\ 4146 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__) 4148 # define CINFO_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4149 #endif // ELPP_INFO_LOG 4150 #if ELPP_WARNING_LOG 4151 # define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...)\ 4152 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__) 4154 # define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4155 #endif // ELPP_WARNING_LOG 4157 # define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...)\ 4158 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__) 4160 # define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4161 #endif // ELPP_DEBUG_LOG 4163 # define CERROR_EVERY_N(writer, occasion, dispatchAction, ...)\ 4164 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__) 4166 # define CERROR_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4167 #endif // ELPP_ERROR_LOG 4169 # define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...)\ 4170 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__) 4172 # define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4173 #endif // ELPP_FATAL_LOG 4175 # define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...)\ 4176 ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__) 4178 # define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter() 4179 #endif // ELPP_TRACE_LOG 4180 #if ELPP_VERBOSE_LOG 4181 # define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...)\ 4182 CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__) 4184 # define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...) el::base::NullWriter() 4185 #endif // ELPP_VERBOSE_LOG 4188 # define CINFO_AFTER_N(writer, n, dispatchAction, ...)\ 4189 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__) 4191 # define CINFO_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4192 #endif // ELPP_INFO_LOG 4193 #if ELPP_WARNING_LOG 4194 # define CWARNING_AFTER_N(writer, n, dispatchAction, ...)\ 4195 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__) 4197 # define CWARNING_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4198 #endif // ELPP_WARNING_LOG 4200 # define CDEBUG_AFTER_N(writer, n, dispatchAction, ...)\ 4201 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__) 4203 # define CDEBUG_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4204 #endif // ELPP_DEBUG_LOG 4206 # define CERROR_AFTER_N(writer, n, dispatchAction, ...)\ 4207 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__) 4209 # define CERROR_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4210 #endif // ELPP_ERROR_LOG 4212 # define CFATAL_AFTER_N(writer, n, dispatchAction, ...)\ 4213 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__) 4215 # define CFATAL_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4216 #endif // ELPP_FATAL_LOG 4218 # define CTRACE_AFTER_N(writer, n, dispatchAction, ...)\ 4219 ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__) 4221 # define CTRACE_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter() 4222 #endif // ELPP_TRACE_LOG 4223 #if ELPP_VERBOSE_LOG 4224 # define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...)\ 4225 CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__) 4227 # define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter() 4228 #endif // ELPP_VERBOSE_LOG 4231 # define CINFO_N_TIMES(writer, n, dispatchAction, ...)\ 4232 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__) 4234 # define CINFO_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4235 #endif // ELPP_INFO_LOG 4236 #if ELPP_WARNING_LOG 4237 # define CWARNING_N_TIMES(writer, n, dispatchAction, ...)\ 4238 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__) 4240 # define CWARNING_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4241 #endif // ELPP_WARNING_LOG 4243 # define CDEBUG_N_TIMES(writer, n, dispatchAction, ...)\ 4244 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__) 4246 # define CDEBUG_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4247 #endif // ELPP_DEBUG_LOG 4249 # define CERROR_N_TIMES(writer, n, dispatchAction, ...)\ 4250 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__) 4252 # define CERROR_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4253 #endif // ELPP_ERROR_LOG 4255 # define CFATAL_N_TIMES(writer, n, dispatchAction, ...)\ 4256 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__) 4258 # define CFATAL_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4259 #endif // ELPP_FATAL_LOG 4261 # define CTRACE_N_TIMES(writer, n, dispatchAction, ...)\ 4262 ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__) 4264 # define CTRACE_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter() 4265 #endif // ELPP_TRACE_LOG 4266 #if ELPP_VERBOSE_LOG 4267 # define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...)\ 4268 CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__) 4270 # define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter() 4271 #endif // ELPP_VERBOSE_LOG 4280 #undef CLOG_VERBOSE_IF 4283 #undef CVLOG_EVERY_N 4285 #undef CVLOG_AFTER_N 4287 #undef CVLOG_N_TIMES 4289 #define CLOG(LEVEL, ...)\ 4290 C##LEVEL(el::base::Writer, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4291 #define CVLOG(vlevel, ...) CVERBOSE(el::base::Writer, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4293 #define CLOG_IF(condition, LEVEL, ...)\ 4294 C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4295 #define CVLOG_IF(condition, vlevel, ...)\ 4296 CVERBOSE_IF(el::base::Writer, condition, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4298 #define CLOG_EVERY_N(n, LEVEL, ...)\ 4299 C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4300 #define CVLOG_EVERY_N(n, vlevel, ...)\ 4301 CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4302 #define CLOG_AFTER_N(n, LEVEL, ...)\ 4303 C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4304 #define CVLOG_AFTER_N(n, vlevel, ...)\ 4305 CVERBOSE_AFTER_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4306 #define CLOG_N_TIMES(n, LEVEL, ...)\ 4307 C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4308 #define CVLOG_N_TIMES(n, vlevel, ...)\ 4309 CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4324 #undef ELPP_CURR_FILE_LOGGER_ID 4325 #if defined(ELPP_DEFAULT_LOGGER) 4326 # define ELPP_CURR_FILE_LOGGER_ID ELPP_DEFAULT_LOGGER 4328 # define ELPP_CURR_FILE_LOGGER_ID el::base::consts::kDefaultLoggerId 4331 #define ELPP_TRACE CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID) 4333 #define LOG(LEVEL) CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4334 #define VLOG(vlevel) CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID) 4336 #define LOG_IF(condition, LEVEL) CLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4337 #define VLOG_IF(condition, vlevel) CVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4339 #define LOG_EVERY_N(n, LEVEL) CLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4340 #define VLOG_EVERY_N(n, vlevel) CVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4341 #define LOG_AFTER_N(n, LEVEL) CLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4342 #define VLOG_AFTER_N(n, vlevel) CVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4343 #define LOG_N_TIMES(n, LEVEL) CLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4344 #define VLOG_N_TIMES(n, vlevel) CVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4354 #define CPLOG(LEVEL, ...)\ 4355 C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4356 #define CPLOG_IF(condition, LEVEL, ...)\ 4357 C##LEVEL##_IF(el::base::PErrorWriter, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4358 #define DCPLOG(LEVEL, ...)\ 4359 if (ELPP_DEBUG_LOG) C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__) 4360 #define DCPLOG_IF(condition, LEVEL, ...)\ 4361 C##LEVEL##_IF(el::base::PErrorWriter, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::NormalLog, __VA_ARGS__) 4362 #define PLOG(LEVEL) CPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4363 #define PLOG_IF(condition, LEVEL) CPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4364 #define DPLOG(LEVEL) DCPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4365 #define DPLOG_IF(condition, LEVEL) DCPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4369 #undef CSYSLOG_EVERY_N 4370 #undef CSYSLOG_AFTER_N 4371 #undef CSYSLOG_N_TIMES 4374 #undef SYSLOG_EVERY_N 4375 #undef SYSLOG_AFTER_N 4376 #undef SYSLOG_N_TIMES 4379 #undef DCSYSLOG_EVERY_N 4380 #undef DCSYSLOG_AFTER_N 4381 #undef DCSYSLOG_N_TIMES 4384 #undef DSYSLOG_EVERY_N 4385 #undef DSYSLOG_AFTER_N 4386 #undef DSYSLOG_N_TIMES 4387 #if defined(ELPP_SYSLOG) 4388 # define CSYSLOG(LEVEL, ...)\ 4389 C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__) 4390 # define CSYSLOG_IF(condition, LEVEL, ...)\ 4391 C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::SysLog, __VA_ARGS__) 4392 # define CSYSLOG_EVERY_N(n, LEVEL, ...) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4393 # define CSYSLOG_AFTER_N(n, LEVEL, ...) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4394 # define CSYSLOG_N_TIMES(n, LEVEL, ...) C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4395 # define SYSLOG(LEVEL) CSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId) 4396 # define SYSLOG_IF(condition, LEVEL) CSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId) 4397 # define SYSLOG_EVERY_N(n, LEVEL) CSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId) 4398 # define SYSLOG_AFTER_N(n, LEVEL) CSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId) 4399 # define SYSLOG_N_TIMES(n, LEVEL) CSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId) 4400 # define DCSYSLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__) 4401 # define DCSYSLOG_IF(condition, LEVEL, ...)\ 4402 C##LEVEL##_IF(el::base::Writer, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::SysLog, __VA_ARGS__) 4403 # define DCSYSLOG_EVERY_N(n, LEVEL, ...)\ 4404 if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4405 # define DCSYSLOG_AFTER_N(n, LEVEL, ...)\ 4406 if (ELPP_DEBUG_LOG) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4407 # define DCSYSLOG_N_TIMES(n, LEVEL, ...)\ 4408 if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__) 4409 # define DSYSLOG(LEVEL) DCSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId) 4410 # define DSYSLOG_IF(condition, LEVEL) DCSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId) 4411 # define DSYSLOG_EVERY_N(n, LEVEL) DCSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId) 4412 # define DSYSLOG_AFTER_N(n, LEVEL) DCSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId) 4413 # define DSYSLOG_N_TIMES(n, LEVEL) DCSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId) 4415 # define CSYSLOG(LEVEL, ...) el::base::NullWriter() 4416 # define CSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter() 4417 # define CSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter() 4418 # define CSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter() 4419 # define CSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter() 4420 # define SYSLOG(LEVEL) el::base::NullWriter() 4421 # define SYSLOG_IF(condition, LEVEL) el::base::NullWriter() 4422 # define SYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter() 4423 # define SYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter() 4424 # define SYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter() 4425 # define DCSYSLOG(LEVEL, ...) el::base::NullWriter() 4426 # define DCSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter() 4427 # define DCSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter() 4428 # define DCSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter() 4429 # define DCSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter() 4430 # define DSYSLOG(LEVEL) el::base::NullWriter() 4431 # define DSYSLOG_IF(condition, LEVEL) el::base::NullWriter() 4432 # define DSYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter() 4433 # define DSYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter() 4434 # define DSYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter() 4435 #endif // defined(ELPP_SYSLOG) 4444 #undef DCLOG_EVERY_N 4445 #undef DCVLOG_EVERY_N 4446 #undef DCLOG_AFTER_N 4447 #undef DCVLOG_AFTER_N 4448 #undef DCLOG_N_TIMES 4449 #undef DCVLOG_N_TIMES 4451 #define DCLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__) 4452 #define DCLOG_VERBOSE(vlevel, ...) if (ELPP_DEBUG_LOG) CLOG_VERBOSE(vlevel, __VA_ARGS__) 4453 #define DCVLOG(vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__) 4455 #define DCLOG_IF(condition, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__) 4456 #define DCVLOG_IF(condition, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__) 4458 #define DCLOG_EVERY_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__) 4459 #define DCVLOG_EVERY_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__) 4460 #define DCLOG_AFTER_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__) 4461 #define DCVLOG_AFTER_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__) 4462 #define DCLOG_N_TIMES(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__) 4463 #define DCVLOG_N_TIMES(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__) 4467 #if !defined(ELPP_NO_DEBUG_MACROS) 4474 #undef DVLOG_EVERY_N 4476 #undef DVLOG_AFTER_N 4478 #undef DVLOG_N_TIMES 4480 #define DLOG(LEVEL) DCLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4481 #define DVLOG(vlevel) DCVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID) 4483 #define DLOG_IF(condition, LEVEL) DCLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4484 #define DVLOG_IF(condition, vlevel) DCVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4486 #define DLOG_EVERY_N(n, LEVEL) DCLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4487 #define DVLOG_EVERY_N(n, vlevel) DCVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4488 #define DLOG_AFTER_N(n, LEVEL) DCLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4489 #define DVLOG_AFTER_N(n, vlevel) DCVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4490 #define DLOG_N_TIMES(n, LEVEL) DCLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID) 4491 #define DVLOG_N_TIMES(n, vlevel) DCVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID) 4492 #endif // defined(ELPP_NO_DEBUG_MACROS) 4493 #if !defined(ELPP_NO_CHECK_MACROS) 4503 #undef CCHECK_BOUNDS 4504 #undef CCHECK_NOTNULL 4505 #undef CCHECK_STRCASEEQ 4506 #undef CCHECK_STRCASENE 4516 #undef CHECK_NOTNULL 4517 #undef CHECK_STRCASEEQ 4518 #undef CHECK_STRCASENE 4519 #define CCHECK(condition, ...) CLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] " 4520 #define CPCHECK(condition, ...) CPLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] " 4521 #define CHECK(condition) CCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) 4522 #define PCHECK(condition) CPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) 4523 #define CCHECK_EQ(a, b, ...) CCHECK(a == b, __VA_ARGS__) 4524 #define CCHECK_NE(a, b, ...) CCHECK(a != b, __VA_ARGS__) 4525 #define CCHECK_LT(a, b, ...) CCHECK(a < b, __VA_ARGS__) 4526 #define CCHECK_GT(a, b, ...) CCHECK(a > b, __VA_ARGS__) 4527 #define CCHECK_LE(a, b, ...) CCHECK(a <= b, __VA_ARGS__) 4528 #define CCHECK_GE(a, b, ...) CCHECK(a >= b, __VA_ARGS__) 4529 #define CCHECK_BOUNDS(val, min, max, ...) CCHECK(val >= min && val <= max, __VA_ARGS__) 4530 #define CHECK_EQ(a, b) CCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID) 4531 #define CHECK_NE(a, b) CCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4532 #define CHECK_LT(a, b) CCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID) 4533 #define CHECK_GT(a, b) CCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID) 4534 #define CHECK_LE(a, b) CCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4535 #define CHECK_GE(a, b) CCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4536 #define CHECK_BOUNDS(val, min, max) CCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID) 4537 #define CCHECK_NOTNULL(ptr, ...) CCHECK((ptr) != nullptr, __VA_ARGS__) 4538 #define CCHECK_STREQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \ 4539 << "Check failed: [" << #str1 << " == " << #str2 << "] " 4540 #define CCHECK_STRNE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \ 4541 << "Check failed: [" << #str1 << " != " << #str2 << "] " 4542 #define CCHECK_STRCASEEQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \ 4543 << "Check failed: [" << #str1 << " == " << #str2 << "] " 4544 #define CCHECK_STRCASENE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \ 4545 << "Check failed: [" << #str1 << " != " << #str2 << "] " 4546 #define CHECK_NOTNULL(ptr) CCHECK_NOTNULL((ptr), ELPP_CURR_FILE_LOGGER_ID) 4547 #define CHECK_STREQ(str1, str2) CCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4548 #define CHECK_STRNE(str1, str2) CCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4549 #define CHECK_STRCASEEQ(str1, str2) CCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4550 #define CHECK_STRCASENE(str1, str2) CCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4558 #undef DCCHECK_BOUNDS 4559 #undef DCCHECK_NOTNULL 4560 #undef DCCHECK_STRCASEEQ 4561 #undef DCCHECK_STRCASENE 4570 #undef DCHECK_BOUNDS_ 4571 #undef DCHECK_NOTNULL 4572 #undef DCHECK_STRCASEEQ 4573 #undef DCHECK_STRCASENE 4575 #define DCCHECK(condition, ...) if (ELPP_DEBUG_LOG) CCHECK(condition, __VA_ARGS__) 4576 #define DCCHECK_EQ(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_EQ(a, b, __VA_ARGS__) 4577 #define DCCHECK_NE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_NE(a, b, __VA_ARGS__) 4578 #define DCCHECK_LT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LT(a, b, __VA_ARGS__) 4579 #define DCCHECK_GT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GT(a, b, __VA_ARGS__) 4580 #define DCCHECK_LE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LE(a, b, __VA_ARGS__) 4581 #define DCCHECK_GE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GE(a, b, __VA_ARGS__) 4582 #define DCCHECK_BOUNDS(val, min, max, ...) if (ELPP_DEBUG_LOG) CCHECK_BOUNDS(val, min, max, __VA_ARGS__) 4583 #define DCCHECK_NOTNULL(ptr, ...) if (ELPP_DEBUG_LOG) CCHECK_NOTNULL((ptr), __VA_ARGS__) 4584 #define DCCHECK_STREQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STREQ(str1, str2, __VA_ARGS__) 4585 #define DCCHECK_STRNE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRNE(str1, str2, __VA_ARGS__) 4586 #define DCCHECK_STRCASEEQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASEEQ(str1, str2, __VA_ARGS__) 4587 #define DCCHECK_STRCASENE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASENE(str1, str2, __VA_ARGS__) 4588 #define DCPCHECK(condition, ...) if (ELPP_DEBUG_LOG) CPCHECK(condition, __VA_ARGS__) 4589 #define DCHECK(condition) DCCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) 4590 #define DCHECK_EQ(a, b) DCCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID) 4591 #define DCHECK_NE(a, b) DCCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4592 #define DCHECK_LT(a, b) DCCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID) 4593 #define DCHECK_GT(a, b) DCCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID) 4594 #define DCHECK_LE(a, b) DCCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4595 #define DCHECK_GE(a, b) DCCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID) 4596 #define DCHECK_BOUNDS(val, min, max) DCCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID) 4597 #define DCHECK_NOTNULL(ptr) DCCHECK_NOTNULL((ptr), ELPP_CURR_FILE_LOGGER_ID) 4598 #define DCHECK_STREQ(str1, str2) DCCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4599 #define DCHECK_STRNE(str1, str2) DCCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4600 #define DCHECK_STRCASEEQ(str1, str2) DCCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4601 #define DCHECK_STRCASENE(str1, str2) DCCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID) 4602 #define DPCHECK(condition) DCPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID) 4603 #endif // defined(ELPP_NO_CHECK_MACROS) 4604 #if defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING) 4605 # define ELPP_USE_DEF_CRASH_HANDLER false 4607 # define ELPP_USE_DEF_CRASH_HANDLER true 4608 #endif // defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING) 4609 #define ELPP_CRASH_HANDLER_INIT 4610 #define ELPP_INIT_EASYLOGGINGPP(val) \ 4613 el::base::type::StoragePointer elStorage(val); \ 4615 el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER); \ 4618 #if ELPP_ASYNC_LOGGING 4619 # define INITIALIZE_EASYLOGGINGPP ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()),\ 4620 new el::base::AsyncDispatchWorker())) 4622 # define INITIALIZE_EASYLOGGINGPP ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()))) 4623 #endif // ELPP_ASYNC_LOGGING 4624 #define INITIALIZE_NULL_EASYLOGGINGPP \ 4627 el::base::type::StoragePointer elStorage;\ 4629 el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\ 4631 #define SHARE_EASYLOGGINGPP(initializedStorage)\ 4634 el::base::type::StoragePointer elStorage(initializedStorage);\ 4636 el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\ 4639 #if defined(ELPP_UNICODE) 4640 # define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv); std::locale::global(std::locale("")) 4642 # define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv) 4643 #endif // defined(ELPP_UNICODE) 4644 #endif // EASYLOGGINGPP_H bool performanceTracking(Level level=Level::Global)
base::TypedConfigurations * typedConfigurations(void)
RegistryWithPred(const RegistryWithPred &sr)
Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor...
bool has(const std::string &id)
CommandLineArgs(int argc, char **argv)
std::size_t size(void) const
Returns total number of arguments. This exclude argv[0].
void convertToColoredOutput(base::type::string_t *logLine, Level level)
static void removeFlag(LoggingFlag flag)
Removes logging flag used internally.
static bool contains(const char *str, char c)
Returns true if c exist in str.
std::shared_ptr< base::type::fstream_t > FileStreamPtr
A mutex wrapper for compiler that dont yet support std::recursive_mutex.
Specifies precision of the subsecond part. It should be within range (1-6).
const std::string & getFilenameCommonPrefix() const
virtual ~RegisteredLoggers(void)
base::RegisteredLoggers * registeredLoggers(void) const
bool parseFromFile(const std::string &configurationFile, Configurations *base=nullptr)
Parses configuration from file.
static Level convertFromStringPrefix(const char *levelStr)
Converts from prefix of levelStr to Level.
virtual const_iterator cbegin(void) const ELPP_FINAL
static char * wcharPtrToCharPtr(const wchar_t *line)
Converst wchar* to char* NOTE: Need to free return value after use!
virtual Container & list(void) ELPP_FINAL
Returns underlying container by reference.
static bool endsWith(const std::string &str, const std::string &end)
Determines whether or not str ends with specified string.
Determines whether or not corresponding level and logger of logging is enabled You may disable all lo...
Configurations * defaultConfigurations(void)
A subsecond precision class containing actual width and offset of the subsecond part.
base::RegisteredHitCounters * hitCounters(void) const
bool enabled(Level level)
PErrorWriter(Level level, const char *file, base::type::LineNumber line, const char *func, base::DispatchAction dispatchAction=base::DispatchAction::NormalLog, base::type::VerboseLevel verboseLevel=0)
static std::string & ltrim(std::string &str)
const base::LogFormat & logFormat(Level level)
Static helpers for developers.
HitCounter(const char *filename, base::type::LineNumber lineNumber)
static void setThreadName(const std::string &name)
Sets thread name for current thread. Requires std::thread.
std::size_t maxLogFileSize(Level level)
static void setDefaultConfigurations(const Configurations &configurations, bool reconfigureExistingLoggers=false)
Sets default configurations. This configuration is used for future (and conditionally for existing) l...
virtual iterator end(void) ELPP_FINAL
Determines whether or not performance tracking is enabled.
static std::string currentHost(void)
Gets current host name or computer name.
base::type::string_t build(const LogMessage *logMessage, bool appendNewLine) const
Creates logger automatically when not available.
virtual ~HitCounter(void)
bool hasFlag(LoggingFlag flag) const
Writer(LogMessage *msg, base::DispatchAction dispatchAction=base::DispatchAction::NormalLog)
const char * filename(void) const
static std::string & replaceAll(std::string &str, char replaceWhat, char replaceWith)
Replaces all instances of replaceWhat with 'replaceWith'. Original variable is changed for performanc...
AbstractRegistry(void)
Default constructor.
Information representing errors in application but application will keep running. ...
static Level convertFromString(const char *levelStr)
Converts from levelStr to Level.
const LogMessage * logMessage(void) const
void setThreadName(const std::string &name)
Sets thread name for current thread. Requires std::thread.
ELPP_EXPORT base::type::StoragePointer elStorage
static bool cStringCaseEq(const char *s1, const char *s2)
Compares cstring equality (case-insensitive) - uses toupper(char) Dont use strcasecmp because of CRT ...
const std::vector< CustomFormatSpecifier > * customFormatSpecifiers(void) const
const std::string & file(void) const
PreRollOutCallback & preRollOutCallback(void)
virtual void log(el::base::type::ostream_t &os) const
virtual const Container & list(void) const ELPP_FINAL
Returns underlying container by constant reference.
Registry(const Registry &sr)
Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor...
static bool parseFromText(const std::string &configurationsString, Configurations *sender, Configurations *base=nullptr)
Parse configurations from configuration string.
std::size_t hitCounts(void) const
virtual ~Configuration(void)
bool enabled(Level level) const
static const base::type::EnumType kMaxValid
Represents maximum valid configuration type. This is used internally and you should not need it...
static void setArgs(int argc, const char **argv)
Sets application arguments and figures out whats active for logging and whats not.
static bool termSupportsColor(void)
Whether or not terminal supports colors.
static std::size_t getSizeOfFile(base::type::fstream_t *fs)
Gets size of file provided in stream.
virtual ~TypedConfigurations(void)
Predicate(Level level, ConfigurationType configurationType)
void reconfigure(void)
Reconfigures logger using existing configurations.
ConfigurationType configurationType(void) const
Gets configuration type of current configuration.
base::type::VerboseLevel m_verboseLevel
virtual ~CommandLineArgs(void)
static ConfigurationType castFromInt(base::type::EnumType c)
Casts int(ushort) to configurationt type, useful for iterating through enum.
HitCounter & operator=(const HitCounter &hitCounter)
#define ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(temp)
virtual ~PErrorWriter(void)
Configuration & operator=(const Configuration &c)
Writer(Level level, const char *file, base::type::LineNumber line, const char *func, base::DispatchAction dispatchAction=base::DispatchAction::NormalLog, base::type::VerboseLevel verboseLevel=0)
bool validateAfterNCounter(const char *filename, base::type::LineNumber lineNumber, std::size_t n)
static std::string getDateTime(const char *format, const base::SubsecondPrecision *ssPrec)
Gets current date and time with a subsecond part.
std::shared_ptr< LogDispatchCallback > LogDispatchCallbackPtr
friend base::type::ostream_t & operator<<(base::type::ostream_t &os, const CommandLineArgs &c)
std::vector< std::string > m_loggerIds
static T * logDispatchCallback(const std::string &id)
virtual const_iterator cend(void) const ELPP_FINAL
Logger * logger(void) const
bool validateEveryNCounter(const char *filename, base::type::LineNumber lineNumber, std::size_t occasion)
virtual ~Configurations(void)
static void reconfigureAllLoggers(ConfigurationType configurationType, const std::string &value)
Reconfigures single configuration for all the loggers.
Informational events most useful for developers to debug application.
void handle(const LogDispatchData *data)
const std::string & id(void) const
void resetLocation(const char *filename, base::type::LineNumber lineNumber)
Resets location of current hit counter.
void setToDefault(void)
Sets configurations to "factory based" configurations.
virtual iterator begin(void) ELPP_FINAL
Severe error information that will presumably abort application.
void removeFlag(LoggingFlag flag)
void setFilenameCommonPrefix(const std::string &prefix)
void setFlags(base::type::EnumType flags)
void setLogMessage(LogMessage *logMessage)
Logger & operator=(const Logger &logger)
void setDefaultLogBuilder(LogBuilderPtr &logBuilderPtr)
Easylogging++ entry namespace.
LoggingFlag
Flags used while writing logs. This flags are set by user.
static void reserveCustomFormatSpecifiers(std::size_t size)
Reserve space for custom format specifiers for performance.
Operating System helper static class used internally. You should not use it.
RegistryWithPred< T_Ptr, Pred >::iterator iterator
Makes sure we have new line for each container log entry.
void uninstallLoggerRegistrationCallback(const std::string &id)
SubsecondPrecision MillisecondsWidth
Type alias of SubsecondPrecision.
Disables comparing performance tracker's checkpoints.
T * loggerRegistrationCallback(const std::string &id)
LogBuilder * logBuilder(void) const
unsigned long int LineNumber
static std::string & toUpper(std::string &str)
Converts string to uppercase.
virtual base::type::string_t build(const LogMessage *logMessage, bool appendNewLine) const =0
static void clearCategories(void)
Clears categories.
base::threading::internal::Mutex Mutex
static struct ::tm * buildTimeInfo(struct timeval *currTime, struct ::tm *timeInfo)
const base::MillisecondsWidth & millisecondsWidth(Level level=Level::Global)
void setFromBase(Configurations *base)
Sets configuration based-off an existing configurations.
#define ELPP_INTERNAL_INFO(lvl, msg)
static bool configureFromArg(const char *argKey)
Configures loggers using command line arg. Ensure you have already set command line args...
const Configurations * configurations(void) const
static base::type::string_t formatTime(unsigned long long time, base::TimestampUnit timestampUnit)
Formats time to get unit accordingly, units like second if > 1000 or minutes if > 60000 etc...
static const std::string getBashOutput(const char *command)
Runs command on terminal and returns the output.
static const base::type::EnumType kMaxValid
Represents maximum valid level. This is used internally and you should not need it.
std::string getThreadName(const std::string &threadId)
Represents unknown level.
static void addFlag(LoggingFlag flag)
Adds logging flag used internally.
static Logger * reconfigureLogger(Logger *logger, const Configurations &configurations)
Reconfigures specified logger with new configurations.
base::DispatchAction dispatchAction(void) const
NullWriter & operator<<(std::ostream &(*)(std::ostream &))
virtual ~RegistryWithPred(void)
Level
Represents enumeration for severity level used to determine level of logging.
void unsetPreRollOutCallback(void)
void initializeLogger(const std::string &loggerId, bool lookup=true, bool needLock=true)
base::threading::Mutex & fileHandle(const LogDispatchData *data)
Thread-safe Configuration repository.
Internal helper class that prevent copy constructor for class.
virtual void handle(const T *handlePtr)=0
void addFlag(LoggingFlag flag)
static bool isValidId(const std::string &id)
static const char * convertToString(Level level)
Converts level to associated const char*.
FormatFlags
Format flags used to determine specifiers that are active for performance improvements.
virtual void unregister(T_Ptr *&ptr) ELPP_FINAL
void setRemainingToDefault(void)
Lets you set the remaining configurations to default.
virtual std::size_t size(void) const ELPP_FINAL
static bool createPath(const std::string &path)
Creates specified path on file system.
Static class that contains helper functions for el::Level.
Adds flag and removes it when scope goes out.
Determines log file (full path) to write logs to for correponding level and logger.
static char * clearBuff(char buff[], std::size_t lim)
Writer & operator<<(std::ostream &(*log)(std::ostream &))
Registry & operator=(const Registry &sr)
Assignment operator that unregisters all the existing registeries and deeply copies each of repo elem...
bool uninstallCustomFormatSpecifier(const char *formatSpecifier)
static std::string getEnvironmentVariable(const char *variableName, const char *defaultVal, const char *alternativeBashCommand=nullptr)
Gets environment variable. This is cross-platform and CRT safe (for VC++)
const std::string & configurationFile(void) const
Gets configuration file used in parsing this configurations.
Contains utilities for cross-platform date/time. This class make use of el::base::utils::Str.
internal::ArgsMatcher< InnerMatcher > Args(const InnerMatcher &matcher)
#define ELPP_INTERNAL_ERROR(msg, pe)
Repository for hit counters used across the application.
Adds spaces b/w logs that separated by left-shift operator.
bool operator()(const Configuration *conf) const
LogMessage(Level level, const std::string &file, base::type::LineNumber line, const std::string &func, base::type::VerboseLevel verboseLevel, Logger *logger)
const std::string & parentApplicationName(void) const
void setFromArgs(const base::utils::CommandLineArgs *commandLineArgs)
void configure(const Configurations &configurations)
Configures the logger using specified configurations.
static void installCustomFormatSpecifier(const CustomFormatSpecifier &customFormatSpecifier)
Installs user defined format specifier and handler.
Base of Easylogging++ friendly class.
Makes sure if -vmodule is used and does not specifies a module, then verbose logging is allowed via t...
static void configureFromGlobal(const char *globalConfigurationFilePath)
Sets configurations from global configuration file.
Information that can be highly useful and vary with verbose logging level.
Determines format of logging corresponding level and logger.
const base::type::string_t & message(void) const
static void buildStrippedFilename(const char *filename, char buff[], const std::string &commonPrefix=NULL, std::size_t limit=base::consts::kSourceFilenameMaxLength)
builds stripped filename and puts it in buff
AbstractRegistry & operator=(AbstractRegistry &&sr)
Assignment move operator.
Disable VModules extensions.
base::type::EnumType flags(void) const
#define ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(temp)
std::unique_ptr< el::base::PerformanceTracker > PerformanceTrackerPtr
Configurations(void)
Default constructor with empty repository.
virtual ~AbstractRegistry(void)
base::type::LineNumber line(void) const
void setDispatchAction(base::DispatchAction dispatchAction)
static const base::LogStreamsReferenceMap * logStreamsReference(void)
Returns log stream reference pointer if needed by user.
void setGlobally(ConfigurationType configurationType, const std::string &value)
Sets configuration for all levels.
static std::string & rtrim(std::string &str)
void setDefaultConfigurations(const Configurations &configurations)
bool operator!=(const AbstractRegistry< T_Ptr, Container > &other)
static void installPreRollOutCallback(const PreRollOutCallback &callback)
Installs pre rollout callback, this callback is triggered when log file is about to be rolled out (ca...
static const el::base::utils::CommandLineArgs * commandLineArgs(void)
Returns command line arguments (pointer) provided to easylogging++.
const base::SubsecondPrecision & subsecondPrecision(Level level=Level::Global)
mdb_size_t count(MDB_cursor *cur)
bool operator==(const SubsecondPrecision &ssPrec)
static void forEachLevel(base::type::EnumType *startIndex, const std::function< bool(void)> &fn)
Applies specified function to each level starting from startIndex.
base::DispatchAction m_dispatchAction
static bool isDigit(char c)
Checks if character is digit. Dont use libc implementation of it to prevent locale issues...
static bool startsWith(const std::string &str, const std::string &start)
Determines whether or not str starts with specified string.
std::unordered_map< std::string, FileStreamPtr > LogStreamsReferenceMap
std::shared_ptr< PerformanceTrackingCallback > PerformanceTrackingCallbackPtr
Main entry point of each logging.
virtual void registerNew(T_Ptr *ptr) ELPP_FINAL
virtual void releaseLock(void) ELPP_FINAL
Used to find configuration from configuration (pointers) repository. Avoid using it.
static bool hasLogger(const std::string &identity)
Whether or not logger with id is registered.
static base::type::StoragePointer storage()
void uninstallLogDispatchCallback(const std::string &id)
static char * convertAndAddToBuff(std::size_t n, int len, char *buf, const char *bufLim, bool zeroPadded=true)
static bool uninstallCustomFormatSpecifier(const char *formatSpecifier)
Uninstalls user defined format specifier and handler.
bool validateNTimesCounter(const char *filename, base::type::LineNumber lineNumber, std::size_t n)
Preserves time format and does not convert it to sec, hour etc (performance tracking only) ...
virtual void acquireLock(void) ELPP_FINAL
base::threading::Mutex & customFormatSpecifiersLock()
#define ELPP_SIMPLE_LOG(LOG_TYPE)
std::function< std::string(const LogMessage *)> FormatSpecifierValueResolver
Resolving function for format specifier.
static void reconfigureAllLoggers(const Configurations &configurations)
Reconfigures all the existing loggers with new configurations.
Command line arguments for application if specified using el::Helpers::setArgs(..) or START_EASYLOGGI...
static T * loggerRegistrationCallback(const std::string &id)
SysLogInitializer(const char *processIdent, int options=0, int facility=0)
std::stringstream & operator<<(std::stringstream &out, const std::wstring &ws)
static bool parseFromFile(const std::string &configurationFile, Configurations *sender, Configurations *base=nullptr)
Parses configuration from file.
base::threading::internal::ScopedLock< base::threading::Mutex > ScopedLock
Represents single configuration that has representing level, configuration type and a string based va...
bool isFlushNeeded(Level level)
friend el::base::type::ostream_t & operator<<(el::base::type::ostream_t &os, const Loggable &loggable)
const struct el::base::consts::@1 kCrashSignals[]
static std::string currentUser(void)
Gets current username.
static bool installCallback(const std::string &id, std::unordered_map< std::string, TPtr > *mapT)
unsigned short VerboseLevel
Predicate(const char *filename, base::type::LineNumber lineNumber)
static void buildBaseFilename(const std::string &fullPath, char buff[], std::size_t limit=base::consts::kSourceFilenameMaxLength, const char *seperator=base::consts::kFilePathSeperator)
builds base filename and puts it in buff
static void uninstallCallback(const std::string &id, std::unordered_map< std::string, TPtr > *mapT)
virtual void log(el::base::type::ostream_t &) const =0
RegisteredLoggers(const LogBuilderPtr &defaultLogBuilder)
static base::type::VerboseLevel verboseLevel(void)
Gets current verbose level.
Container::iterator iterator
virtual void registerNew(const T_Key &uniqKey, T_Ptr *ptr) ELPP_FINAL
Registers new registry to repository.
virtual ~LogBuilder(void)
static const std::string & getFilenameCommonPrefix()
Gets filename common prefix.
virtual void deepCopy(const AbstractRegistry< T_Ptr, Container > &)=0
static void setDefaultLogBuilder(el::LogBuilderPtr &logBuilderPtr)
Changes default log builder for future loggers.
static std::string convertTemplateToStdString(const T &templ)
Converts template to std::string - useful for loggable classes to log containers within log(std::ostr...
bool vModulesEnabled(void)
Whether or not vModules enabled.
std::enable_if< std::is_integral< T >::value, Writer & >::type operator<<(T log)
static bool hasFlag(LoggingFlag flag)
Determines whether or not certain flag is active.
Abstract registry (aka repository) that provides basic interface for pointer repository specified by ...
static void setCategories(const char *categories, bool clear=true)
Sets categories as specified (on the fly)
const std::string & filename(Level level)
virtual void unregisterAll(void)=0
Unregisters all the pointers from current repository.
const base::type::char_t * unit
std::size_t operator()(const el::Level &l) const
Writes nothing - Used when certain log is disabled.
std::shared_ptr< LogBuilder > LogBuilderPtr
Alias of SubsecondPrecision (for backward compatibility)
Make terminal output colorful for supported terminals.
#define ELPP_LITERAL(txt)
bool hasParam(const char *paramKey) const
Return true if arguments has a param (not having a value) i,e without '='.
bool validateEveryN(const char *filename, base::type::LineNumber lineNumber, std::size_t n)
Validates counter for every N, i.e, registers new if does not exist otherwise updates original one...
static Level castFromInt(base::type::EnumType l)
Casts int(ushort) to level, useful for iterating through enum.
RegistryWithPred & operator=(const RegistryWithPred &sr)
Assignment operator that unregisters all the existing registeries and deeply copies each of repo elem...
static void gettimeofday(struct timeval *tv)
Cross platform gettimeofday for Windows and unix platform. This can be used to determine current micr...
bool operator()(const HitCounter *counter)
Useful when application has potentially harmful situtaions.
void clearCategories(void)
MessageBuilder & operator<<(const std::string &msg)
static void clearVModules(void)
Clears vmodules.
TypedConfigurations(Configurations *configurations, base::LogStreamsReferenceMap *logStreamsReference)
Constructor to initialize (construct) the object off el::Configurations.
Class that keeps record of current line hit for occasional logging.
When handling crashes by default, detailed crash reason will be logged as well.
DispatchAction
Action to be taken for dispatching.
Enables strict file rolling.
static std::string extractPathFromFilename(const std::string &fullPath, const char *seperator=base::consts::kFilePathSeperator)
Extracts path of filename with leading slash.
LogDispatcher(bool proceed, LogMessage *logMessage, base::DispatchAction dispatchAction)
static bool cStringEq(const char *s1, const char *s2)
Compares cstring equality - uses strcmp.
static bool pathExists(const char *path, bool considerFile=false)
Determines whether or not provided path exist in current file system.
Scoped lock for compiler that dont yet support std::lock_guard.
virtual ~SysLogInitializer(void)
Writer & construct(Logger *logger, bool needLock=true)
virtual bool empty(void) const ELPP_FINAL
Configuration(const Configuration &c)
friend class el::base::PerformanceTracker
base::Storage * StoragePointer
Removes flag and add it when scope goes out.
static bool wildCardMatch(const char *str, const char *pattern)
Matches wildcards, '*' and '?' only supported.
Configurations * configurations(void)
std::string getCategories()
VRegistry(base::type::VerboseLevel level, base::type::EnumType *pFlags)
void setArgs(int argc, const char **argv)
Sets arguments and parses them.
base::type::VerboseLevel verboseLevel(void) const
static const base::type::EnumType kMinValid
Represents minimum valid configuration type. Useful when iterating through enum.
RegistryWithPred< T_Ptr, Pred >::const_iterator const_iterator
static std::string & trim(std::string &str)
const base::type::LineNumber m_line
static base::type::EnumType castToInt(ConfigurationType configurationType)
Casts configuration type to int, useful for iterating through enum.
void setEnabled(bool enabled)
static ConfigurationType convertFromString(const char *configStr)
Converts from configStr to ConfigurationType.
Flushes log with every log-entry (performance sensative) - Disabled by default.
A pointer registry mechanism to manage memory and provide search functionalities. (non-predicate vers...
void setLogBuilder(const LogBuilderPtr &logBuilder)
static const char * convertToString(ConfigurationType configurationType)
Converts configuration type to associated const char*.
Mainly useful to represent current progress of application.
virtual ~ThreadSafe(void)
static std::string getCategories()
Gets current categories.
static void forEachConfigType(base::type::EnumType *startIndex, const std::function< bool(void)> &fn)
Applies specified function to each configuration type starting from startIndex.
Storage(const LogBuilderPtr &defaultLogBuilder)
void unregister(Logger *&logger)
bool hasParamWithValue(const char *paramKey) const
Returns true if arguments contain paramKey with a value (seperated by '=')
const T & move(const T &t)
Configurations with data types.
friend base::type::ostream_t & operator<<(base::type::ostream_t &os, const RegistryWithPred &sr)
std::function< void(const char *, std::size_t)> PreRollOutCallback
static base::type::fstream_t * newFileStream(const std::string &filename)
Creates new out file stream for specified filename.
bool empty(void) const
Returns true if no params available. This exclude argv[0].
static bool hasCustomFormatSpecifier(const char *formatSpecifier)
Returns true if custom format specifier is installed.
static bool installLogDispatchCallback(const std::string &id)
Installs post log dispatch callback, this callback is triggered when log is dispatched.
TimestampUnit
Enum to represent timestamp unit.
const GenericPointer< typename T::ValueType > T2 value
static void replaceFirstWithEscape(base::type::string_t &str, const base::type::string_t &replaceWhat, const base::type::string_t &replaceWith)
Static helpers to deal with loggers and their configurations.
static const std::string releaseDate(void)
Release date of current version.
bool installLogDispatchCallback(const std::string &id)
Specifies number of log entries to hold until we flush pending log data.
base::LogStreamsReferenceMap * logStreamsReference(void)
void flush(void)
Flushes logger to sync all log files for all levels.
base::type::fstream_t * fileStream(Level level)
static void setVerboseLevel(base::type::VerboseLevel level)
Sets verbose level on the fly.
Base of thread safe class, this class is inheritable-only.
std::shared_ptr< LoggerRegistrationCallback > LoggerRegistrationCallbackPtr
base::debug::CrashHandler elCrashHandler
virtual base::threading::Mutex & lock(void) ELPP_FINAL
#define ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(temp)
Container::const_iterator const_iterator
Registry< T_Ptr, T_Key >::const_iterator const_iterator
const char * getParamValue(const char *paramKey) const
Returns value of arguments.
bool hasCustomFormatSpecifier(const char *formatSpecifier)
static void setVModules(const char *modules)
Sets vmodules as specified (on the fly)
CommandLineArgs(int argc, const char **argv)
NullWriter & operator<<(const T &)
void setCategories(const char *categories, bool clear=true)
base::MessageBuilder m_messageBuilder
Static class that contains helper functions for el::ConfigurationType.
static const base::type::EnumType kMinValid
Represents minimum valid level. Useful when iterating through enum.
static T * callback(const std::string &id, std::unordered_map< std::string, TPtr > *mapT)
static void uninstallPreRollOutCallback(void)
Uninstalls pre rollout callback.
void initialize(Logger *logger)
virtual void log(el::base::type::ostream_t &os) const
void setLoggingLevel(Level level)
Represents a logger holding ID and configurations we need to write logs.
base::type::LineNumber lineNumber(void) const
static void uninstallLogDispatchCallback(const std::string &id)
Uninstalls log dispatch callback.
static char * addToBuff(const char *str, char *buf, const char *bufLim)
void triggerDispatch(void)
const struct el::base::consts::@0 kTimeFormats[]
static void validateFileRolling(Logger *logger, Level level)
void setModules(const char *modules)
String utilities helper class used internally. You should not use it.
Represents registries for verbose logging.
virtual ~ScopedLock(void)
Generic level that represents all the levels. Useful when setting global configuration for all levels...
void setLevel(base::type::VerboseLevel level)
Sets verbose level. Accepted range is 0-9.
void setValue(const std::string &value)
Set string based configuration value.
Whether or not to write corresponding log to log file.
#define ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(temp)
static bool installLoggerRegistrationCallback(const std::string &id)
Installs logger registration callback, this callback is triggered when new logger is registered...
static std::vector< std::string > * populateAllLoggerIds(std::vector< std::string > *targetList)
Populates all logger IDs in current repository.
friend class el::base::PerformanceTracker
const base::HitCounter * getCounter(const char *filename, base::type::LineNumber lineNumber)
Gets hit counter registered at specified position.
static void setStorage(base::type::StoragePointer storage)
Shares logging repository (base::Storage)
std::size_t logFlushThreshold(Level level)
static void setFilenameCommonPrefix(const std::string &prefix)
Sets filename common prefix.
virtual void handle(const LogDispatchData *data)
bool parseFromText(const std::string &configurationsString, Configurations *base=nullptr)
Parse configurations from configuration string.
const std::string & value(void) const
Gets string based configuration value.
T * logDispatchCallback(const std::string &id)
Registry< T_Ptr, T_Key >::iterator iterator
const base::utils::CommandLineArgs * commandLineArgs(void) const
Whether or not to write corresponding level and logger log to standard output. By standard output mea...
ConfigurationType
Represents enumeration of ConfigurationType used to configure or access certain aspect of logging...
static std::string getThreadName()
bool validateNTimes(const char *filename, base::type::LineNumber lineNumber, std::size_t n)
Validates counter for hits are <= n, i.e, registers new if does not exist otherwise updates original ...
const GenericPointer< typename T::ValueType > & pointer
static void uninstallLoggerRegistrationCallback(const std::string &id)
Uninstalls log dispatch callback.
HitCounter(const HitCounter &hitCounter)
Parser used internally to parse configurations from file or text.
bool hasConfiguration(ConfigurationType configurationType)
Determines whether or not specified configuration type exists in the repository.
A pointer registry mechanism to manage memory and provide search functionalities. (predicate version)...
static const Configurations * defaultConfigurations(void)
Returns current default.
bool toStandardOutput(Level level)
static void setArgs(int argc, char **argv)
Sets application arguments and figures out whats active for logging and whats not.
ScopedRemoveFlag(LoggingFlag flag)
AbstractRegistry(AbstractRegistry &&sr)
Move constructor that is useful for base classes.
static void setLoggingLevel(Level level)
Sets hierarchy for logging. Needs to enable logging flag (HierarchicalLogging)
void get(std::istream &input, bool &res)
std::stringstream stringstream_t
static el::base::type::StoragePointer & getELPP()
Level level(void) const
Gets level of current configuration.
virtual void unregisterAll(void) ELPP_FINAL
Unregisters all the pointers from current repository.
void validateHitCounts(std::size_t n)
Validates hit counts and resets it if necessary.
void setParentApplicationName(const std::string &parentApplicationName)
ScopedAddFlag(LoggingFlag flag)
static bool unregisterLogger(const std::string &identity)
Unregisters logger - use it only when you know what you are doing, you may unregister loggers initial...
static base::TypedConfigurations defaultTypedConfigurations(void)
Default typed configuration based on existing defaultConf.
base::VRegistry * vRegistry(void) const
bool allowed(Level level, const std::string &category)
void reinitDeepCopy(const AbstractRegistry< T_Ptr, Container > &sr)
error
Tracks LMDB error codes.
bool validateAfterN(const char *filename, base::type::LineNumber lineNumber, std::size_t n)
Validates counter for hits >= N, i.e, registers new if does not exist otherwise updates original one...
static unsigned long long getTimeDifference(const struct timeval &endTime, const struct timeval &startTime, base::TimestampUnit timestampUnit)
Gets time difference in milli/micro second depending on timestampUnit.
const std::string & func(void) const
Enables hierarchical logging.
static std::string timevalToString(struct timeval tval, const char *format, const el::base::SubsecondPrecision *ssPrec)
Converts timeval (struct from ctime) to string using specified format and subsecond precision...
virtual void unregisterAll(void) ELPP_FINAL
Unregisters all the pointers from current repository.
const std::unordered_map< std::string, base::type::VerboseLevel > & modules(void) const
static void flushAll(void)
Flushes all loggers for all levels - Be careful if you dont know how many loggers are registered...
void setPreRollOutCallback(const PreRollOutCallback &callback)
static base::type::EnumType castToInt(Level level)
Casts level to int, useful for iterating through enum.
Supports use of multiple logging in same macro, e.g, CLOG(INFO, "default", "network") ...
SubsecondPrecision(int width)
void unregister(const T_Key &uniqKey)
Unregisters single entry mapped to specified unique key.
void clear(void)
Clears repository so that all the configurations are unset.
#define ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(temp)
base::type::VerboseLevel level(void) const
Information that can be useful to back-trace certain events - mostly useful than debug logs...
void verbose(enum verbosity_value level, const char *format,...) ATTR_FORMAT(printf
Internal helper class that makes all default constructors private.
Easylogging++ management storage.
static Logger * getLogger(const std::string &identity, bool registerIfNotAvailable=true)
Gets existing or registers new logger.
MessageBuilder & operator<<(std::ostream &(*OStreamMani)(std::ostream &))
Specifies log file max size.
bool installLoggerRegistrationCallback(const std::string &id)
void installCustomFormatSpecifier(const CustomFormatSpecifier &customFormatSpecifier)
bool operator==(const AbstractRegistry< T_Ptr, Container > &other)
Allows to disable application abortion when logged using FATAL level.
static const std::string version(void)
Current version number.