logging.h revision 116680a4aac90f2aa7413d9095a592090648e557
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef BASE_LOGGING_H_ 6#define BASE_LOGGING_H_ 7 8#include <cassert> 9#include <string> 10#include <cstring> 11#include <sstream> 12 13#include "base/base_export.h" 14#include "base/basictypes.h" 15#include "base/debug/debugger.h" 16#include "build/build_config.h" 17 18// 19// Optional message capabilities 20// ----------------------------- 21// Assertion failed messages and fatal errors are displayed in a dialog box 22// before the application exits. However, running this UI creates a message 23// loop, which causes application messages to be processed and potentially 24// dispatched to existing application windows. Since the application is in a 25// bad state when this assertion dialog is displayed, these messages may not 26// get processed and hang the dialog, or the application might go crazy. 27// 28// Therefore, it can be beneficial to display the error dialog in a separate 29// process from the main application. When the logging system needs to display 30// a fatal error dialog box, it will look for a program called 31// "DebugMessage.exe" in the same directory as the application executable. It 32// will run this application with the message as the command line, and will 33// not include the name of the application as is traditional for easier 34// parsing. 35// 36// The code for DebugMessage.exe is only one line. In WinMain, do: 37// MessageBox(NULL, GetCommandLineW(), L"Fatal Error", 0); 38// 39// If DebugMessage.exe is not found, the logging code will use a normal 40// MessageBox, potentially causing the problems discussed above. 41 42 43// Instructions 44// ------------ 45// 46// Make a bunch of macros for logging. The way to log things is to stream 47// things to LOG(<a particular severity level>). E.g., 48// 49// LOG(INFO) << "Found " << num_cookies << " cookies"; 50// 51// You can also do conditional logging: 52// 53// LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; 54// 55// The CHECK(condition) macro is active in both debug and release builds and 56// effectively performs a LOG(FATAL) which terminates the process and 57// generates a crashdump unless a debugger is attached. 58// 59// There are also "debug mode" logging macros like the ones above: 60// 61// DLOG(INFO) << "Found cookies"; 62// 63// DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; 64// 65// All "debug mode" logging is compiled away to nothing for non-debug mode 66// compiles. LOG_IF and development flags also work well together 67// because the code can be compiled away sometimes. 68// 69// We also have 70// 71// LOG_ASSERT(assertion); 72// DLOG_ASSERT(assertion); 73// 74// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion; 75// 76// There are "verbose level" logging macros. They look like 77// 78// VLOG(1) << "I'm printed when you run the program with --v=1 or more"; 79// VLOG(2) << "I'm printed when you run the program with --v=2 or more"; 80// 81// These always log at the INFO log level (when they log at all). 82// The verbose logging can also be turned on module-by-module. For instance, 83// --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0 84// will cause: 85// a. VLOG(2) and lower messages to be printed from profile.{h,cc} 86// b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc} 87// c. VLOG(3) and lower messages to be printed from files prefixed with 88// "browser" 89// d. VLOG(4) and lower messages to be printed from files under a 90// "chromeos" directory. 91// e. VLOG(0) and lower messages to be printed from elsewhere 92// 93// The wildcarding functionality shown by (c) supports both '*' (match 94// 0 or more characters) and '?' (match any single character) 95// wildcards. Any pattern containing a forward or backward slash will 96// be tested against the whole pathname and not just the module. 97// E.g., "*/foo/bar/*=2" would change the logging level for all code 98// in source files under a "foo/bar" directory. 99// 100// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as 101// 102// if (VLOG_IS_ON(2)) { 103// // do some logging preparation and logging 104// // that can't be accomplished with just VLOG(2) << ...; 105// } 106// 107// There is also a VLOG_IF "verbose level" condition macro for sample 108// cases, when some extra computation and preparation for logs is not 109// needed. 110// 111// VLOG_IF(1, (size > 1024)) 112// << "I'm printed when size is more than 1024 and when you run the " 113// "program with --v=1 or more"; 114// 115// We also override the standard 'assert' to use 'DLOG_ASSERT'. 116// 117// Lastly, there is: 118// 119// PLOG(ERROR) << "Couldn't do foo"; 120// DPLOG(ERROR) << "Couldn't do foo"; 121// PLOG_IF(ERROR, cond) << "Couldn't do foo"; 122// DPLOG_IF(ERROR, cond) << "Couldn't do foo"; 123// PCHECK(condition) << "Couldn't do foo"; 124// DPCHECK(condition) << "Couldn't do foo"; 125// 126// which append the last system error to the message in string form (taken from 127// GetLastError() on Windows and errno on POSIX). 128// 129// The supported severity levels for macros that allow you to specify one 130// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL. 131// 132// Very important: logging a message at the FATAL severity level causes 133// the program to terminate (after the message is logged). 134// 135// There is the special severity of DFATAL, which logs FATAL in debug mode, 136// ERROR in normal mode. 137 138namespace logging { 139 140// TODO(avi): do we want to do a unification of character types here? 141#if defined(OS_WIN) 142typedef wchar_t PathChar; 143#else 144typedef char PathChar; 145#endif 146 147// Where to record logging output? A flat file and/or system debug log 148// via OutputDebugString. 149enum LoggingDestination { 150 LOG_NONE = 0, 151 LOG_TO_FILE = 1 << 0, 152 LOG_TO_SYSTEM_DEBUG_LOG = 1 << 1, 153 154 LOG_TO_ALL = LOG_TO_FILE | LOG_TO_SYSTEM_DEBUG_LOG, 155 156 // On Windows, use a file next to the exe; on POSIX platforms, where 157 // it may not even be possible to locate the executable on disk, use 158 // stderr. 159#if defined(OS_WIN) 160 LOG_DEFAULT = LOG_TO_FILE, 161#elif defined(OS_POSIX) 162 LOG_DEFAULT = LOG_TO_SYSTEM_DEBUG_LOG, 163#endif 164}; 165 166// Indicates that the log file should be locked when being written to. 167// Unless there is only one single-threaded process that is logging to 168// the log file, the file should be locked during writes to make each 169// log output atomic. Other writers will block. 170// 171// All processes writing to the log file must have their locking set for it to 172// work properly. Defaults to LOCK_LOG_FILE. 173enum LogLockingState { LOCK_LOG_FILE, DONT_LOCK_LOG_FILE }; 174 175// On startup, should we delete or append to an existing log file (if any)? 176// Defaults to APPEND_TO_OLD_LOG_FILE. 177enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE }; 178 179struct BASE_EXPORT LoggingSettings { 180 // The defaults values are: 181 // 182 // logging_dest: LOG_DEFAULT 183 // log_file: NULL 184 // lock_log: LOCK_LOG_FILE 185 // delete_old: APPEND_TO_OLD_LOG_FILE 186 LoggingSettings(); 187 188 LoggingDestination logging_dest; 189 190 // The three settings below have an effect only when LOG_TO_FILE is 191 // set in |logging_dest|. 192 const PathChar* log_file; 193 LogLockingState lock_log; 194 OldFileDeletionState delete_old; 195}; 196 197// Define different names for the BaseInitLoggingImpl() function depending on 198// whether NDEBUG is defined or not so that we'll fail to link if someone tries 199// to compile logging.cc with NDEBUG but includes logging.h without defining it, 200// or vice versa. 201#if NDEBUG 202#define BaseInitLoggingImpl BaseInitLoggingImpl_built_with_NDEBUG 203#else 204#define BaseInitLoggingImpl BaseInitLoggingImpl_built_without_NDEBUG 205#endif 206 207// Implementation of the InitLogging() method declared below. We use a 208// more-specific name so we can #define it above without affecting other code 209// that has named stuff "InitLogging". 210BASE_EXPORT bool BaseInitLoggingImpl(const LoggingSettings& settings); 211 212// Sets the log file name and other global logging state. Calling this function 213// is recommended, and is normally done at the beginning of application init. 214// If you don't call it, all the flags will be initialized to their default 215// values, and there is a race condition that may leak a critical section 216// object if two threads try to do the first log at the same time. 217// See the definition of the enums above for descriptions and default values. 218// 219// The default log file is initialized to "debug.log" in the application 220// directory. You probably don't want this, especially since the program 221// directory may not be writable on an enduser's system. 222// 223// This function may be called a second time to re-direct logging (e.g after 224// loging in to a user partition), however it should never be called more than 225// twice. 226inline bool InitLogging(const LoggingSettings& settings) { 227 return BaseInitLoggingImpl(settings); 228} 229 230// Sets the log level. Anything at or above this level will be written to the 231// log file/displayed to the user (if applicable). Anything below this level 232// will be silently ignored. The log level defaults to 0 (everything is logged 233// up to level INFO) if this function is not called. 234// Note that log messages for VLOG(x) are logged at level -x, so setting 235// the min log level to negative values enables verbose logging. 236BASE_EXPORT void SetMinLogLevel(int level); 237 238// Gets the current log level. 239BASE_EXPORT int GetMinLogLevel(); 240 241// Gets the VLOG default verbosity level. 242BASE_EXPORT int GetVlogVerbosity(); 243 244// Gets the current vlog level for the given file (usually taken from 245// __FILE__). 246 247// Note that |N| is the size *with* the null terminator. 248BASE_EXPORT int GetVlogLevelHelper(const char* file_start, size_t N); 249 250template <size_t N> 251int GetVlogLevel(const char (&file)[N]) { 252 return GetVlogLevelHelper(file, N); 253} 254 255// Sets the common items you want to be prepended to each log message. 256// process and thread IDs default to off, the timestamp defaults to on. 257// If this function is not called, logging defaults to writing the timestamp 258// only. 259BASE_EXPORT void SetLogItems(bool enable_process_id, bool enable_thread_id, 260 bool enable_timestamp, bool enable_tickcount); 261 262// Sets whether or not you'd like to see fatal debug messages popped up in 263// a dialog box or not. 264// Dialogs are not shown by default. 265BASE_EXPORT void SetShowErrorDialogs(bool enable_dialogs); 266 267// Sets the Log Assert Handler that will be used to notify of check failures. 268// The default handler shows a dialog box and then terminate the process, 269// however clients can use this function to override with their own handling 270// (e.g. a silent one for Unit Tests) 271typedef void (*LogAssertHandlerFunction)(const std::string& str); 272BASE_EXPORT void SetLogAssertHandler(LogAssertHandlerFunction handler); 273 274// Sets the Log Message Handler that gets passed every log message before 275// it's sent to other log destinations (if any). 276// Returns true to signal that it handled the message and the message 277// should not be sent to other log destinations. 278typedef bool (*LogMessageHandlerFunction)(int severity, 279 const char* file, int line, size_t message_start, const std::string& str); 280BASE_EXPORT void SetLogMessageHandler(LogMessageHandlerFunction handler); 281BASE_EXPORT LogMessageHandlerFunction GetLogMessageHandler(); 282 283typedef int LogSeverity; 284const LogSeverity LOG_VERBOSE = -1; // This is level 1 verbosity 285// Note: the log severities are used to index into the array of names, 286// see log_severity_names. 287const LogSeverity LOG_INFO = 0; 288const LogSeverity LOG_WARNING = 1; 289const LogSeverity LOG_ERROR = 2; 290const LogSeverity LOG_FATAL = 3; 291const LogSeverity LOG_NUM_SEVERITIES = 4; 292 293// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode 294#ifdef NDEBUG 295const LogSeverity LOG_DFATAL = LOG_ERROR; 296#else 297const LogSeverity LOG_DFATAL = LOG_FATAL; 298#endif 299 300// A few definitions of macros that don't generate much code. These are used 301// by LOG() and LOG_IF, etc. Since these are used all over our code, it's 302// better to have compact code for these operations. 303#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \ 304 logging::ClassName(__FILE__, __LINE__, logging::LOG_INFO , ##__VA_ARGS__) 305#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \ 306 logging::ClassName(__FILE__, __LINE__, logging::LOG_WARNING , ##__VA_ARGS__) 307#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \ 308 logging::ClassName(__FILE__, __LINE__, logging::LOG_ERROR , ##__VA_ARGS__) 309#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \ 310 logging::ClassName(__FILE__, __LINE__, logging::LOG_FATAL , ##__VA_ARGS__) 311#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \ 312 logging::ClassName(__FILE__, __LINE__, logging::LOG_DFATAL , ##__VA_ARGS__) 313 314#define COMPACT_GOOGLE_LOG_INFO \ 315 COMPACT_GOOGLE_LOG_EX_INFO(LogMessage) 316#define COMPACT_GOOGLE_LOG_WARNING \ 317 COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage) 318#define COMPACT_GOOGLE_LOG_ERROR \ 319 COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage) 320#define COMPACT_GOOGLE_LOG_FATAL \ 321 COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage) 322#define COMPACT_GOOGLE_LOG_DFATAL \ 323 COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage) 324 325#if defined(OS_WIN) 326// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets 327// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us 328// to keep using this syntax, we define this macro to do the same thing 329// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that 330// the Windows SDK does for consistency. 331#define ERROR 0 332#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \ 333 COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__) 334#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR 335// Needed for LOG_IS_ON(ERROR). 336const LogSeverity LOG_0 = LOG_ERROR; 337#endif 338 339// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also, 340// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will 341// always fire if they fail. 342#define LOG_IS_ON(severity) \ 343 ((::logging::LOG_ ## severity) >= ::logging::GetMinLogLevel()) 344 345// We can't do any caching tricks with VLOG_IS_ON() like the 346// google-glog version since it requires GCC extensions. This means 347// that using the v-logging functions in conjunction with --vmodule 348// may be slow. 349#define VLOG_IS_ON(verboselevel) \ 350 ((verboselevel) <= ::logging::GetVlogLevel(__FILE__)) 351 352// Helper macro which avoids evaluating the arguments to a stream if 353// the condition doesn't hold. 354#define LAZY_STREAM(stream, condition) \ 355 !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream) 356 357// We use the preprocessor's merging operator, "##", so that, e.g., 358// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny 359// subtle difference between ostream member streaming functions (e.g., 360// ostream::operator<<(int) and ostream non-member streaming functions 361// (e.g., ::operator<<(ostream&, string&): it turns out that it's 362// impossible to stream something like a string directly to an unnamed 363// ostream. We employ a neat hack by calling the stream() member 364// function of LogMessage which seems to avoid the problem. 365#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream() 366 367#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity)) 368#define LOG_IF(severity, condition) \ 369 LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) 370 371#define SYSLOG(severity) LOG(severity) 372#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition) 373 374// The VLOG macros log with negative verbosities. 375#define VLOG_STREAM(verbose_level) \ 376 logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream() 377 378#define VLOG(verbose_level) \ 379 LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level)) 380 381#define VLOG_IF(verbose_level, condition) \ 382 LAZY_STREAM(VLOG_STREAM(verbose_level), \ 383 VLOG_IS_ON(verbose_level) && (condition)) 384 385#if defined (OS_WIN) 386#define VPLOG_STREAM(verbose_level) \ 387 logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \ 388 ::logging::GetLastSystemErrorCode()).stream() 389#elif defined(OS_POSIX) 390#define VPLOG_STREAM(verbose_level) \ 391 logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \ 392 ::logging::GetLastSystemErrorCode()).stream() 393#endif 394 395#define VPLOG(verbose_level) \ 396 LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level)) 397 398#define VPLOG_IF(verbose_level, condition) \ 399 LAZY_STREAM(VPLOG_STREAM(verbose_level), \ 400 VLOG_IS_ON(verbose_level) && (condition)) 401 402// TODO(akalin): Add more VLOG variants, e.g. VPLOG. 403 404#define LOG_ASSERT(condition) \ 405 LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " 406#define SYSLOG_ASSERT(condition) \ 407 SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " 408 409#if defined(OS_WIN) 410#define PLOG_STREAM(severity) \ 411 COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \ 412 ::logging::GetLastSystemErrorCode()).stream() 413#elif defined(OS_POSIX) 414#define PLOG_STREAM(severity) \ 415 COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \ 416 ::logging::GetLastSystemErrorCode()).stream() 417#endif 418 419#define PLOG(severity) \ 420 LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity)) 421 422#define PLOG_IF(severity, condition) \ 423 LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) 424 425// The actual stream used isn't important. 426#define EAT_STREAM_PARAMETERS \ 427 true ? (void) 0 : ::logging::LogMessageVoidify() & LOG_STREAM(FATAL) 428 429// CHECK dies with a fatal error if condition is not true. It is *not* 430// controlled by NDEBUG, so the check will be executed regardless of 431// compilation mode. 432// 433// We make sure CHECK et al. always evaluates their arguments, as 434// doing CHECK(FunctionWithSideEffect()) is a common idiom. 435 436#if defined(OFFICIAL_BUILD) && defined(NDEBUG) && !defined(OS_ANDROID) 437 438// Make all CHECK functions discard their log strings to reduce code 439// bloat for official release builds. 440 441// TODO(akalin): This would be more valuable if there were some way to 442// remove BreakDebugger() from the backtrace, perhaps by turning it 443// into a macro (like __debugbreak() on Windows). 444#define CHECK(condition) \ 445 !(condition) ? ::base::debug::BreakDebugger() : EAT_STREAM_PARAMETERS 446 447#define PCHECK(condition) CHECK(condition) 448 449#define CHECK_OP(name, op, val1, val2) CHECK((val1) op (val2)) 450 451#else 452 453#define CHECK(condition) \ 454 LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \ 455 << "Check failed: " #condition ". " 456 457#define PCHECK(condition) \ 458 LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \ 459 << "Check failed: " #condition ". " 460 461// Helper macro for binary operators. 462// Don't use this macro directly in your code, use CHECK_EQ et al below. 463// 464// TODO(akalin): Rewrite this so that constructs like if (...) 465// CHECK_EQ(...) else { ... } work properly. 466#define CHECK_OP(name, op, val1, val2) \ 467 if (std::string* _result = \ 468 logging::Check##name##Impl((val1), (val2), \ 469 #val1 " " #op " " #val2)) \ 470 logging::LogMessage(__FILE__, __LINE__, _result).stream() 471 472#endif 473 474// Build the error message string. This is separate from the "Impl" 475// function template because it is not performance critical and so can 476// be out of line, while the "Impl" code should be inline. Caller 477// takes ownership of the returned string. 478template<class t1, class t2> 479std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) { 480 std::ostringstream ss; 481 ss << names << " (" << v1 << " vs. " << v2 << ")"; 482 std::string* msg = new std::string(ss.str()); 483 return msg; 484} 485 486// MSVC doesn't like complex extern templates and DLLs. 487#if !defined(COMPILER_MSVC) 488// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated 489// in logging.cc. 490extern template BASE_EXPORT std::string* MakeCheckOpString<int, int>( 491 const int&, const int&, const char* names); 492extern template BASE_EXPORT 493std::string* MakeCheckOpString<unsigned long, unsigned long>( 494 const unsigned long&, const unsigned long&, const char* names); 495extern template BASE_EXPORT 496std::string* MakeCheckOpString<unsigned long, unsigned int>( 497 const unsigned long&, const unsigned int&, const char* names); 498extern template BASE_EXPORT 499std::string* MakeCheckOpString<unsigned int, unsigned long>( 500 const unsigned int&, const unsigned long&, const char* names); 501extern template BASE_EXPORT 502std::string* MakeCheckOpString<std::string, std::string>( 503 const std::string&, const std::string&, const char* name); 504#endif 505 506// Helper functions for CHECK_OP macro. 507// The (int, int) specialization works around the issue that the compiler 508// will not instantiate the template version of the function on values of 509// unnamed enum type - see comment below. 510#define DEFINE_CHECK_OP_IMPL(name, op) \ 511 template <class t1, class t2> \ 512 inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \ 513 const char* names) { \ 514 if (v1 op v2) return NULL; \ 515 else return MakeCheckOpString(v1, v2, names); \ 516 } \ 517 inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \ 518 if (v1 op v2) return NULL; \ 519 else return MakeCheckOpString(v1, v2, names); \ 520 } 521DEFINE_CHECK_OP_IMPL(EQ, ==) 522DEFINE_CHECK_OP_IMPL(NE, !=) 523DEFINE_CHECK_OP_IMPL(LE, <=) 524DEFINE_CHECK_OP_IMPL(LT, < ) 525DEFINE_CHECK_OP_IMPL(GE, >=) 526DEFINE_CHECK_OP_IMPL(GT, > ) 527#undef DEFINE_CHECK_OP_IMPL 528 529#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2) 530#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2) 531#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2) 532#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2) 533#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2) 534#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2) 535 536#if defined(NDEBUG) 537#define ENABLE_DLOG 0 538#else 539#define ENABLE_DLOG 1 540#endif 541 542#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) 543#define DCHECK_IS_ON 0 544#else 545#define DCHECK_IS_ON 1 546#endif 547 548// Definitions for DLOG et al. 549 550#if ENABLE_DLOG 551 552#define DLOG_IS_ON(severity) LOG_IS_ON(severity) 553#define DLOG_IF(severity, condition) LOG_IF(severity, condition) 554#define DLOG_ASSERT(condition) LOG_ASSERT(condition) 555#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition) 556#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition) 557#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition) 558 559#else // ENABLE_DLOG 560 561// If ENABLE_DLOG is off, we want to avoid emitting any references to 562// |condition| (which may reference a variable defined only if NDEBUG 563// is not defined). Contrast this with DCHECK et al., which has 564// different behavior. 565 566#define DLOG_IS_ON(severity) false 567#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS 568#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS 569#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS 570#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS 571#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS 572 573#endif // ENABLE_DLOG 574 575// DEBUG_MODE is for uses like 576// if (DEBUG_MODE) foo.CheckThatFoo(); 577// instead of 578// #ifndef NDEBUG 579// foo.CheckThatFoo(); 580// #endif 581// 582// We tie its state to ENABLE_DLOG. 583enum { DEBUG_MODE = ENABLE_DLOG }; 584 585#undef ENABLE_DLOG 586 587#define DLOG(severity) \ 588 LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity)) 589 590#define DPLOG(severity) \ 591 LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity)) 592 593#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel)) 594 595#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel)) 596 597// Definitions for DCHECK et al. 598 599#if DCHECK_IS_ON 600 601#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ 602 COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__) 603#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL 604const LogSeverity LOG_DCHECK = LOG_FATAL; 605 606#else // DCHECK_IS_ON 607 608// These are just dummy values. 609#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \ 610 COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__) 611#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO 612const LogSeverity LOG_DCHECK = LOG_INFO; 613 614#endif // DCHECK_IS_ON 615 616// DCHECK et al. make sure to reference |condition| regardless of 617// whether DCHECKs are enabled; this is so that we don't get unused 618// variable warnings if the only use of a variable is in a DCHECK. 619// This behavior is different from DLOG_IF et al. 620 621#define DCHECK(condition) \ 622 LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON && !(condition)) \ 623 << "Check failed: " #condition ". " 624 625#define DPCHECK(condition) \ 626 LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON && !(condition)) \ 627 << "Check failed: " #condition ". " 628 629// Helper macro for binary operators. 630// Don't use this macro directly in your code, use DCHECK_EQ et al below. 631#define DCHECK_OP(name, op, val1, val2) \ 632 if (DCHECK_IS_ON) \ 633 if (std::string* _result = \ 634 logging::Check##name##Impl((val1), (val2), \ 635 #val1 " " #op " " #val2)) \ 636 logging::LogMessage( \ 637 __FILE__, __LINE__, ::logging::LOG_DCHECK, \ 638 _result).stream() 639 640// Equality/Inequality checks - compare two values, and log a 641// LOG_DCHECK message including the two values when the result is not 642// as expected. The values must have operator<<(ostream, ...) 643// defined. 644// 645// You may append to the error message like so: 646// DCHECK_NE(1, 2) << ": The world must be ending!"; 647// 648// We are very careful to ensure that each argument is evaluated exactly 649// once, and that anything which is legal to pass as a function argument is 650// legal here. In particular, the arguments may be temporary expressions 651// which will end up being destroyed at the end of the apparent statement, 652// for example: 653// DCHECK_EQ(string("abc")[1], 'b'); 654// 655// WARNING: These may not compile correctly if one of the arguments is a pointer 656// and the other is NULL. To work around this, simply static_cast NULL to the 657// type of the desired pointer. 658 659#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2) 660#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2) 661#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2) 662#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2) 663#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2) 664#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2) 665 666#if defined(NDEBUG) && defined(OS_CHROMEOS) 667#define NOTREACHED() LOG(ERROR) << "NOTREACHED() hit in " << \ 668 __FUNCTION__ << ". " 669#else 670#define NOTREACHED() DCHECK(false) 671#endif 672 673// Redefine the standard assert to use our nice log files 674#undef assert 675#define assert(x) DLOG_ASSERT(x) 676 677// This class more or less represents a particular log message. You 678// create an instance of LogMessage and then stream stuff to it. 679// When you finish streaming to it, ~LogMessage is called and the 680// full message gets streamed to the appropriate destination. 681// 682// You shouldn't actually use LogMessage's constructor to log things, 683// though. You should use the LOG() macro (and variants thereof) 684// above. 685class BASE_EXPORT LogMessage { 686 public: 687 // Used for LOG(severity). 688 LogMessage(const char* file, int line, LogSeverity severity); 689 690 // Used for CHECK_EQ(), etc. Takes ownership of the given string. 691 // Implied severity = LOG_FATAL. 692 LogMessage(const char* file, int line, std::string* result); 693 694 // Used for DCHECK_EQ(), etc. Takes ownership of the given string. 695 LogMessage(const char* file, int line, LogSeverity severity, 696 std::string* result); 697 698 ~LogMessage(); 699 700 std::ostream& stream() { return stream_; } 701 702 private: 703 void Init(const char* file, int line); 704 705 LogSeverity severity_; 706 std::ostringstream stream_; 707 size_t message_start_; // Offset of the start of the message (past prefix 708 // info). 709 // The file and line information passed in to the constructor. 710 const char* file_; 711 const int line_; 712 713#if defined(OS_WIN) 714 // Stores the current value of GetLastError in the constructor and restores 715 // it in the destructor by calling SetLastError. 716 // This is useful since the LogMessage class uses a lot of Win32 calls 717 // that will lose the value of GLE and the code that called the log function 718 // will have lost the thread error value when the log call returns. 719 class SaveLastError { 720 public: 721 SaveLastError(); 722 ~SaveLastError(); 723 724 unsigned long get_error() const { return last_error_; } 725 726 protected: 727 unsigned long last_error_; 728 }; 729 730 SaveLastError last_error_; 731#endif 732 733 DISALLOW_COPY_AND_ASSIGN(LogMessage); 734}; 735 736// A non-macro interface to the log facility; (useful 737// when the logging level is not a compile-time constant). 738inline void LogAtLevel(int const log_level, std::string const &msg) { 739 LogMessage(__FILE__, __LINE__, log_level).stream() << msg; 740} 741 742// This class is used to explicitly ignore values in the conditional 743// logging macros. This avoids compiler warnings like "value computed 744// is not used" and "statement has no effect". 745class LogMessageVoidify { 746 public: 747 LogMessageVoidify() { } 748 // This has to be an operator with a precedence lower than << but 749 // higher than ?: 750 void operator&(std::ostream&) { } 751}; 752 753#if defined(OS_WIN) 754typedef unsigned long SystemErrorCode; 755#elif defined(OS_POSIX) 756typedef int SystemErrorCode; 757#endif 758 759// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to 760// pull in windows.h just for GetLastError() and DWORD. 761BASE_EXPORT SystemErrorCode GetLastSystemErrorCode(); 762BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code); 763 764#if defined(OS_WIN) 765// Appends a formatted system message of the GetLastError() type. 766class BASE_EXPORT Win32ErrorLogMessage { 767 public: 768 Win32ErrorLogMessage(const char* file, 769 int line, 770 LogSeverity severity, 771 SystemErrorCode err); 772 773 // Appends the error message before destructing the encapsulated class. 774 ~Win32ErrorLogMessage(); 775 776 std::ostream& stream() { return log_message_.stream(); } 777 778 private: 779 SystemErrorCode err_; 780 LogMessage log_message_; 781 782 DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage); 783}; 784#elif defined(OS_POSIX) 785// Appends a formatted system message of the errno type 786class BASE_EXPORT ErrnoLogMessage { 787 public: 788 ErrnoLogMessage(const char* file, 789 int line, 790 LogSeverity severity, 791 SystemErrorCode err); 792 793 // Appends the error message before destructing the encapsulated class. 794 ~ErrnoLogMessage(); 795 796 std::ostream& stream() { return log_message_.stream(); } 797 798 private: 799 SystemErrorCode err_; 800 LogMessage log_message_; 801 802 DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage); 803}; 804#endif // OS_WIN 805 806// Closes the log file explicitly if open. 807// NOTE: Since the log file is opened as necessary by the action of logging 808// statements, there's no guarantee that it will stay closed 809// after this call. 810BASE_EXPORT void CloseLogFile(); 811 812// Async signal safe logging mechanism. 813BASE_EXPORT void RawLog(int level, const char* message); 814 815#define RAW_LOG(level, message) logging::RawLog(logging::LOG_ ## level, message) 816 817#define RAW_CHECK(condition) \ 818 do { \ 819 if (!(condition)) \ 820 logging::RawLog(logging::LOG_FATAL, "Check failed: " #condition "\n"); \ 821 } while (0) 822 823#if defined(OS_WIN) 824// Returns the default log file path. 825BASE_EXPORT std::wstring GetLogFileFullPath(); 826#endif 827 828} // namespace logging 829 830// Note that "The behavior of a C++ program is undefined if it adds declarations 831// or definitions to namespace std or to a namespace within namespace std unless 832// otherwise specified." --C++11[namespace.std] 833// 834// We've checked that this particular definition has the intended behavior on 835// our implementations, but it's prone to breaking in the future, and please 836// don't imitate this in your own definitions without checking with some 837// standard library experts. 838namespace std { 839// These functions are provided as a convenience for logging, which is where we 840// use streams (it is against Google style to use streams in other places). It 841// is designed to allow you to emit non-ASCII Unicode strings to the log file, 842// which is normally ASCII. It is relatively slow, so try not to use it for 843// common cases. Non-ASCII characters will be converted to UTF-8 by these 844// operators. 845BASE_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr); 846inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) { 847 return out << wstr.c_str(); 848} 849} // namespace std 850 851// The NOTIMPLEMENTED() macro annotates codepaths which have 852// not been implemented yet. 853// 854// The implementation of this macro is controlled by NOTIMPLEMENTED_POLICY: 855// 0 -- Do nothing (stripped by compiler) 856// 1 -- Warn at compile time 857// 2 -- Fail at compile time 858// 3 -- Fail at runtime (DCHECK) 859// 4 -- [default] LOG(ERROR) at runtime 860// 5 -- LOG(ERROR) at runtime, only once per call-site 861 862#ifndef NOTIMPLEMENTED_POLICY 863#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD) 864#define NOTIMPLEMENTED_POLICY 0 865#else 866// Select default policy: LOG(ERROR) 867#define NOTIMPLEMENTED_POLICY 4 868#endif 869#endif 870 871#if defined(COMPILER_GCC) 872// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name 873// of the current function in the NOTIMPLEMENTED message. 874#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__ 875#else 876#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED" 877#endif 878 879#if NOTIMPLEMENTED_POLICY == 0 880#define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS 881#elif NOTIMPLEMENTED_POLICY == 1 882// TODO, figure out how to generate a warning 883#define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED) 884#elif NOTIMPLEMENTED_POLICY == 2 885#define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED) 886#elif NOTIMPLEMENTED_POLICY == 3 887#define NOTIMPLEMENTED() NOTREACHED() 888#elif NOTIMPLEMENTED_POLICY == 4 889#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG 890#elif NOTIMPLEMENTED_POLICY == 5 891#define NOTIMPLEMENTED() do {\ 892 static bool logged_once = false;\ 893 LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\ 894 logged_once = true;\ 895} while(0);\ 896EAT_STREAM_PARAMETERS 897#endif 898 899#endif // BASE_LOGGING_H_ 900