123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613 |
- <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
- <html>
- <head>
- <title>How To Use Google Logging Library (glog)</title>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
- <link href="http://www.google.com/favicon.ico" type="image/x-icon"
- rel="shortcut icon">
- <link href="designstyle.css" type="text/css" rel="stylesheet">
- <style type="text/css">
- <!--
- ol.bluelist li {
- color: #3366ff;
- font-family: sans-serif;
- }
- ol.bluelist li p {
- color: #000;
- font-family: "Times Roman", times, serif;
- }
- ul.blacklist li {
- color: #000;
- font-family: "Times Roman", times, serif;
- }
- //-->
- </style>
- </head>
- <body>
- <h1>How To Use Google Logging Library (glog)</h1>
- <small>(as of
- <script type=text/javascript>
- var lm = new Date(document.lastModified);
- document.write(lm.toDateString());
- </script>)
- </small>
- <br>
- <h2> <A NAME=intro>Introduction</A> </h2>
- <p><b>Google glog</b> is a library that implements application-level
- logging. This library provides logging APIs based on C++-style
- streams and various helper macros.
- You can log a message by simply streaming things to LOG(<a
- particular <a href="#severity">severity level</a>>), e.g.
- <pre>
- #include <glog/logging.h>
- int main(int argc, char* argv[]) {
- // Initialize Google's logging library.
- google::InitGoogleLogging(argv[0]);
- // ...
- LOG(INFO) << "Found " << num_cookies << " cookies";
- }
- </pre>
- <p>Google glog defines a series of macros that simplify many common logging
- tasks. You can log messages by severity level, control logging
- behavior from the command line, log based on conditionals, abort the
- program when expected conditions are not met, introduce your own
- verbose logging levels, and more. This document describes the
- functionality supported by glog. Please note that this document
- doesn't describe all features in this library, but the most useful
- ones. If you want to find less common features, please check
- header files under <code>src/glog</code> directory.
- <h2> <A NAME=severity>Severity Level</A> </h2>
- <p>
- You can specify one of the following severity levels (in
- increasing order of severity): <code>INFO</code>, <code>WARNING</code>,
- <code>ERROR</code>, and <code>FATAL</code>.
- Logging a <code>FATAL</code> message terminates the program (after the
- message is logged).
- Note that messages of a given severity are logged not only in the
- logfile for that severity, but also in all logfiles of lower severity.
- E.g., a message of severity <code>FATAL</code> will be logged to the
- logfiles of severity <code>FATAL</code>, <code>ERROR</code>,
- <code>WARNING</code>, and <code>INFO</code>.
- <p>
- The <code>DFATAL</code> severity logs a <code>FATAL</code> error in
- debug mode (i.e., there is no <code>NDEBUG</code> macro defined), but
- avoids halting the program in production by automatically reducing the
- severity to <code>ERROR</code>.
- <p>Unless otherwise specified, glog writes to the filename
- "/tmp/<program name>.<hostname>.<user name>.log.<severity level>.<date>.<time>.<pid>"
- (e.g., "/tmp/hello_world.example.com.hamaji.log.INFO.20080709-222411.10474").
- By default, glog copies the log messages of severity level
- <code>ERROR</code> or <code>FATAL</code> to standard error (stderr)
- in addition to log files.
- <h2><A NAME=flags>Setting Flags</A></h2>
- <p>Several flags influence glog's output behavior.
- If the <a href="http://code.google.com/p/google-gflags/">Google
- gflags library</a> is installed on your machine, the
- <code>configure</code> script (see the INSTALL file in the package for
- detail of this script) will automatically detect and use it,
- allowing you to pass flags on the command line. For example, if you
- want to turn the flag <code>--logtostderr</code> on, you can start
- your application with the following command line:
- <pre>
- ./your_application --logtostderr=1
- </pre>
- If the Google gflags library isn't installed, you set flags via
- environment variables, prefixing the flag name with "GLOG_", e.g.
- <pre>
- GLOG_logtostderr=1 ./your_application
- </pre>
- <!-- TODO(hamaji): Fill the version number
- <p>By glog version 0.x.x, you can use GLOG_* environment variables
- even if you have gflags. If both an environment variable and a flag
- are specified, the value specified by a flag wins. E.g., if GLOG_v=0
- and --v=1, the verbosity will be 1, not 0.
- -->
- <p>The following flags are most commonly used:
- <dl>
- <dt><code>logtostderr</code> (<code>bool</code>, default=<code>false</code>)
- <dd>Log messages to stderr instead of logfiles.<br>
- Note: you can set binary flags to <code>true</code> by specifying
- <code>1</code>, <code>true</code>, or <code>yes</code> (case
- insensitive).
- Also, you can set binary flags to <code>false</code> by specifying
- <code>0</code>, <code>false</code>, or <code>no</code> (again, case
- insensitive).
- <dt><code>stderrthreshold</code> (<code>int</code>, default=2, which
- is <code>ERROR</code>)
- <dd>Copy log messages at or above this level to stderr in
- addition to logfiles. The numbers of severity levels
- <code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>, and
- <code>FATAL</code> are 0, 1, 2, and 3, respectively.
- <dt><code>minloglevel</code> (<code>int</code>, default=0, which
- is <code>INFO</code>)
- <dd>Log messages at or above this level. Again, the numbers of
- severity levels <code>INFO</code>, <code>WARNING</code>,
- <code>ERROR</code>, and <code>FATAL</code> are 0, 1, 2, and 3,
- respectively.
- <dt><code>log_dir</code> (<code>string</code>, default="")
- <dd>If specified, logfiles are written into this directory instead
- of the default logging directory.
- <dt><code>v</code> (<code>int</code>, default=0)
- <dd>Show all <code>VLOG(m)</code> messages for <code>m</code> less or
- equal the value of this flag. Overridable by --vmodule.
- See <a href="#verbose">the section about verbose logging</a> for more
- detail.
- <dt><code>vmodule</code> (<code>string</code>, default="")
- <dd>Per-module verbose level. The argument has to contain a
- comma-separated list of <module name>=<log level>.
- <module name>
- is a glob pattern (e.g., <code>gfs*</code> for all modules whose name
- starts with "gfs"), matched against the filename base
- (that is, name ignoring .cc/.h./-inl.h).
- <log level> overrides any value given by --v.
- See also <a href="#verbose">the section about verbose logging</a>.
- </dl>
- <p>There are some other flags defined in logging.cc. Please grep the
- source code for "DEFINE_" to see a complete list of all flags.
- <p>You can also modify flag values in your program by modifying global
- variables <code>FLAGS_*</code> . Most settings start working
- immediately after you update <code>FLAGS_*</code> . The exceptions are
- the flags related to destination files. For example, you might want to
- set <code>FLAGS_log_dir</code> before
- calling <code>google::InitGoogleLogging</code> . Here is an example:
- <pre>
- LOG(INFO) << "file";
- // Most flags work immediately after updating values.
- FLAGS_logtostderr = 1;
- LOG(INFO) << "stderr";
- FLAGS_logtostderr = 0;
- // This won't change the log destination. If you want to set this
- // value, you should do this before google::InitGoogleLogging .
- FLAGS_log_dir = "/some/log/directory";
- LOG(INFO) << "the same file";
- </pre>
- <h2><A NAME=conditional>Conditional / Occasional Logging</A></h2>
- <p>Sometimes, you may only want to log a message under certain
- conditions. You can use the following macros to perform conditional
- logging:
- <pre>
- LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
- </pre>
- The "Got lots of cookies" message is logged only when the variable
- <code>num_cookies</code> exceeds 10.
- If a line of code is executed many times, it may be useful to only log
- a message at certain intervals. This kind of logging is most useful
- for informational messages.
- <pre>
- LOG_EVERY_N(INFO, 10) << "Got the " << google::COUNTER << "th cookie";
- </pre>
- <p>The above line outputs a log messages on the 1st, 11th,
- 21st, ... times it is executed. Note that the special
- <code>google::COUNTER</code> value is used to identify which repetition is
- happening.
- <p>You can combine conditional and occasional logging with the
- following macro.
- <pre>
- LOG_IF_EVERY_N(INFO, (size > 1024), 10) << "Got the " << google::COUNTER
- << "th big cookie";
- </pre>
- <p>Instead of outputting a message every nth time, you can also limit
- the output to the first n occurrences:
- <pre>
- LOG_FIRST_N(INFO, 20) << "Got the " << google::COUNTER << "th cookie";
- </pre>
- <p>Outputs log messages for the first 20 times it is executed. Again,
- the <code>google::COUNTER</code> identifier indicates which repetition is
- happening.
- <h2><A NAME=debug>Debug Mode Support</A></h2>
- <p>Special "debug mode" logging macros only have an effect in debug
- mode and are compiled away to nothing for non-debug mode
- compiles. Use these macros to avoid slowing down your production
- application due to excessive logging.
- <pre>
- DLOG(INFO) << "Found cookies";
- DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
- DLOG_EVERY_N(INFO, 10) << "Got the " << google::COUNTER << "th cookie";
- </pre>
- <h2><A NAME=check>CHECK Macros</A></h2>
- <p>It is a good practice to check expected conditions in your program
- frequently to detect errors as early as possible. The
- <code>CHECK</code> macro provides the ability to abort the application
- when a condition is not met, similar to the <code>assert</code> macro
- defined in the standard C library.
- <p><code>CHECK</code> aborts the application if a condition is not
- true. Unlike <code>assert</code>, it is *not* controlled by
- <code>NDEBUG</code>, so the check will be executed regardless of
- compilation mode. Therefore, <code>fp->Write(x)</code> in the
- following example is always executed:
- <pre>
- CHECK(fp->Write(x) == 4) << "Write failed!";
- </pre>
- <p>There are various helper macros for
- equality/inequality checks - <code>CHECK_EQ</code>,
- <code>CHECK_NE</code>, <code>CHECK_LE</code>, <code>CHECK_LT</code>,
- <code>CHECK_GE</code>, and <code>CHECK_GT</code>.
- They compare two values, and log a
- <code>FATAL</code> message including the two values when the result is
- not as expected. The values must have <code>operator<<(ostream,
- ...)</code> defined.
- <p>You may append to the error message like so:
- <pre>
- CHECK_NE(1, 2) << ": The world must be ending!";
- </pre>
- <p>We are very careful to ensure that each argument is evaluated exactly
- once, and that anything which is legal to pass as a function argument is
- legal here. In particular, the arguments may be temporary expressions
- which will end up being destroyed at the end of the apparent statement,
- for example:
- <pre>
- CHECK_EQ(string("abc")[1], 'b');
- </pre>
- <p>The compiler reports an error if one of the arguments is a
- pointer and the other is NULL. To work around this, simply static_cast
- NULL to the type of the desired pointer.
- <pre>
- CHECK_EQ(some_ptr, static_cast<SomeType*>(NULL));
- </pre>
- <p>Better yet, use the CHECK_NOTNULL macro:
- <pre>
- CHECK_NOTNULL(some_ptr);
- some_ptr->DoSomething();
- </pre>
- <p>Since this macro returns the given pointer, this is very useful in
- constructor initializer lists.
- <pre>
- struct S {
- S(Something* ptr) : ptr_(CHECK_NOTNULL(ptr)) {}
- Something* ptr_;
- };
- </pre>
- <p>Note that you cannot use this macro as a C++ stream due to this
- feature. Please use <code>CHECK_EQ</code> described above to log a
- custom message before aborting the application.
- <p>If you are comparing C strings (char *), a handy set of macros
- performs case sensitive as well as case insensitive comparisons -
- <code>CHECK_STREQ</code>, <code>CHECK_STRNE</code>,
- <code>CHECK_STRCASEEQ</code>, and <code>CHECK_STRCASENE</code>. The
- CASE versions are case-insensitive. You can safely pass <code>NULL</code>
- pointers for this macro. They treat <code>NULL</code> and any
- non-<code>NULL</code> string as not equal. Two <code>NULL</code>s are
- equal.
- <p>Note that both arguments may be temporary strings which are
- destructed at the end of the current "full expression"
- (e.g., <code>CHECK_STREQ(Foo().c_str(), Bar().c_str())</code> where
- <code>Foo</code> and <code>Bar</code> return C++'s
- <code>std::string</code>).
- <p>The <code>CHECK_DOUBLE_EQ</code> macro checks the equality of two
- floating point values, accepting a small error margin.
- <code>CHECK_NEAR</code> accepts a third floating point argument, which
- specifies the acceptable error margin.
- <h2><A NAME=verbose>Verbose Logging</A></h2>
- <p>When you are chasing difficult bugs, thorough log messages are very
- useful. However, you may want to ignore too verbose messages in usual
- development. For such verbose logging, glog provides the
- <code>VLOG</code> macro, which allows you to define your own numeric
- logging levels. The <code>--v</code> command line option controls
- which verbose messages are logged:
- <pre>
- VLOG(1) << "I'm printed when you run the program with --v=1 or higher";
- VLOG(2) << "I'm printed when you run the program with --v=2 or higher";
- </pre>
- <p>With <code>VLOG</code>, the lower the verbose level, the more
- likely messages are to be logged. For example, if
- <code>--v==1</code>, <code>VLOG(1)</code> will log, but
- <code>VLOG(2)</code> will not log. This is opposite of the severity
- level, where <code>INFO</code> is 0, and <code>ERROR</code> is 2.
- <code>--minloglevel</code> of 1 will log <code>WARNING</code> and
- above. Though you can specify any integers for both <code>VLOG</code>
- macro and <code>--v</code> flag, the common values for them are small
- positive integers. For example, if you write <code>VLOG(0)</code>,
- you should specify <code>--v=-1</code> or lower to silence it. This
- is less useful since we may not want verbose logs by default in most
- cases. The <code>VLOG</code> macros always log at the
- <code>INFO</code> log level (when they log at all).
- <p>Verbose logging can be controlled from the command line on a
- per-module basis:
- <pre>
- --vmodule=mapreduce=2,file=1,gfs*=3 --v=0
- </pre>
- <p>will:
- <ul>
- <li>a. Print VLOG(2) and lower messages from mapreduce.{h,cc}
- <li>b. Print VLOG(1) and lower messages from file.{h,cc}
- <li>c. Print VLOG(3) and lower messages from files prefixed with "gfs"
- <li>d. Print VLOG(0) and lower messages from elsewhere
- </ul>
- <p>The wildcarding functionality shown by (c) supports both '*'
- (matches 0 or more characters) and '?' (matches any single character)
- wildcards. Please also check the section about <a
- href="#flags">command line flags</a>.
- <p>There's also <code>VLOG_IS_ON(n)</code> "verbose level" condition
- macro. This macro returns true when the <code>--v</code> is equal or
- greater than <code>n</code>. To be used as
- <pre>
- if (VLOG_IS_ON(2)) {
- // do some logging preparation and logging
- // that can't be accomplished with just VLOG(2) << ...;
- }
- </pre>
- <p>Verbose level condition macros <code>VLOG_IF</code>,
- <code>VLOG_EVERY_N</code> and <code>VLOG_IF_EVERY_N</code> behave
- analogous to <code>LOG_IF</code>, <code>LOG_EVERY_N</code>,
- <code>LOF_IF_EVERY</code>, but accept a numeric verbosity level as
- opposed to a severity level.
- <pre>
- VLOG_IF(1, (size > 1024))
- << "I'm printed when size is more than 1024 and when you run the "
- "program with --v=1 or more";
- VLOG_EVERY_N(1, 10)
- << "I'm printed every 10th occurrence, and when you run the program "
- "with --v=1 or more. Present occurence is " << google::COUNTER;
- VLOG_IF_EVERY_N(1, (size > 1024), 10)
- << "I'm printed on every 10th occurence of case when size is more "
- " than 1024, when you run the program with --v=1 or more. ";
- "Present occurence is " << google::COUNTER;
- </pre>
- <h2> <A name="signal">Failure Signal Handler</A> </h2>
- <p>
- The library provides a convenient signal handler that will dump useful
- information when the program crashes on certain signals such as SIGSEGV.
- The signal handler can be installed by
- google::InstallFailureSignalHandler(). The following is an example of output
- from the signal handler.
- <pre>
- *** Aborted at 1225095260 (unix time) try "date -d @1225095260" if you are using GNU date ***
- *** SIGSEGV (@0x0) received by PID 17711 (TID 0x7f893090a6f0) from PID 0; stack trace: ***
- PC: @ 0x412eb1 TestWaitingLogSink::send()
- @ 0x7f892fb417d0 (unknown)
- @ 0x412eb1 TestWaitingLogSink::send()
- @ 0x7f89304f7f06 google::LogMessage::SendToLog()
- @ 0x7f89304f35af google::LogMessage::Flush()
- @ 0x7f89304f3739 google::LogMessage::~LogMessage()
- @ 0x408cf4 TestLogSinkWaitTillSent()
- @ 0x4115de main
- @ 0x7f892f7ef1c4 (unknown)
- @ 0x4046f9 (unknown)
- </pre>
- <p>
- By default, the signal handler writes the failure dump to the standard
- error. You can customize the destination by InstallFailureWriter().
- <h2> <A name="misc">Miscellaneous Notes</A> </h2>
- <h3><A NAME=message>Performance of Messages</A></h3>
- <p>The conditional logging macros provided by glog (e.g.,
- <code>CHECK</code>, <code>LOG_IF</code>, <code>VLOG</code>, ...) are
- carefully implemented and don't execute the right hand side
- expressions when the conditions are false. So, the following check
- may not sacrifice the performance of your application.
- <pre>
- CHECK(obj.ok) << obj.CreatePrettyFormattedStringButVerySlow();
- </pre>
- <h3><A NAME=failure>User-defined Failure Function</A></h3>
- <p><code>FATAL</code> severity level messages or unsatisfied
- <code>CHECK</code> condition terminate your program. You can change
- the behavior of the termination by
- <code>InstallFailureFunction</code>.
- <pre>
- void YourFailureFunction() {
- // Reports something...
- exit(1);
- }
- int main(int argc, char* argv[]) {
- google::InstallFailureFunction(&YourFailureFunction);
- }
- </pre>
- <p>By default, glog tries to dump stacktrace and makes the program
- exit with status 1. The stacktrace is produced only when you run the
- program on an architecture for which glog supports stack tracing (as
- of September 2008, glog supports stack tracing for x86 and x86_64).
- <h3><A NAME=raw>Raw Logging</A></h3>
- <p>The header file <code><glog/raw_logging.h></code> can be
- used for thread-safe logging, which does not allocate any memory or
- acquire any locks. Therefore, the macros defined in this
- header file can be used by low-level memory allocation and
- synchronization code.
- Please check <code>src/glog/raw_logging.h.in</code> for detail.
- </p>
- <h3><A NAME=plog>Google Style perror()</A></h3>
- <p><code>PLOG()</code> and <code>PLOG_IF()</code> and
- <code>PCHECK()</code> behave exactly like their <code>LOG*</code> and
- <code>CHECK</code> equivalents with the addition that they append a
- description of the current state of errno to their output lines.
- E.g.
- <pre>
- PCHECK(write(1, NULL, 2) >= 0) << "Write NULL failed";
- </pre>
- <p>This check fails with the following error message.
- <pre>
- F0825 185142 test.cc:22] Check failed: write(1, NULL, 2) >= 0 Write NULL failed: Bad address [14]
- </pre>
- <h3><A NAME=syslog>Syslog</A></h3>
- <p><code>SYSLOG</code>, <code>SYSLOG_IF</code>, and
- <code>SYSLOG_EVERY_N</code> macros are available.
- These log to syslog in addition to the normal logs. Be aware that
- logging to syslog can drastically impact performance, especially if
- syslog is configured for remote logging! Make sure you understand the
- implications of outputting to syslog before you use these macros. In
- general, it's wise to use these macros sparingly.
- <h3><A NAME=strip>Strip Logging Messages</A></h3>
- <p>Strings used in log messages can increase the size of your binary
- and present a privacy concern. You can therefore instruct glog to
- remove all strings which fall below a certain severity level by using
- the GOOGLE_STRIP_LOG macro:
- <p>If your application has code like this:
- <pre>
- #define GOOGLE_STRIP_LOG 1 // this must go before the #include!
- #include <glog/logging.h>
- </pre>
- <p>The compiler will remove the log messages whose severities are less
- than the specified integer value. Since
- <code>VLOG</code> logs at the severity level <code>INFO</code>
- (numeric value <code>0</code>),
- setting <code>GOOGLE_STRIP_LOG</code> to 1 or greater removes
- all log messages associated with <code>VLOG</code>s as well as
- <code>INFO</code> log statements.
- <h3><A NAME=windows>Notes for Windows users</A></h3>
- <p>Google glog defines a severity level <code>ERROR</code>, which is
- also defined in <code>windows.h</code> . You can make glog not define
- <code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>,
- and <code>FATAL</code> by defining
- <code>GLOG_NO_ABBREVIATED_SEVERITIES</code> before
- including <code>glog/logging.h</code> . Even with this macro, you can
- still use the iostream like logging facilities:
- <pre>
- #define GLOG_NO_ABBREVIATED_SEVERITIES
- #include <windows.h>
- #include <glog/logging.h>
- // ...
- LOG(ERROR) << "This should work";
- LOG_IF(ERROR, x > y) << "This should be also OK";
- </pre>
- <p>
- However, you cannot
- use <code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>,
- and <code>FATAL</code> anymore for functions defined
- in <code>glog/logging.h</code> .
- <pre>
- #define GLOG_NO_ABBREVIATED_SEVERITIES
- #include <windows.h>
- #include <glog/logging.h>
- // ...
- // This won't work.
- // google::FlushLogFiles(google::ERROR);
- // Use this instead.
- google::FlushLogFiles(google::GLOG_ERROR);
- </pre>
- <p>
- If you don't need <code>ERROR</code> defined
- by <code>windows.h</code>, there are a couple of more workarounds
- which sometimes don't work:
- <ul>
- <li>#define <code>WIN32_LEAN_AND_MEAN</code> or <code>NOGDI</code>
- <strong>before</strong> you #include <code>windows.h</code> .
- <li>#undef <code>ERROR</code> <strong>after</strong> you #include
- <code>windows.h</code> .
- </ul>
- <p>See <a href="http://code.google.com/p/google-glog/issues/detail?id=33">
- this issue</a> for more detail.
- <hr>
- <address>
- Shinichiro Hamaji<br>
- Gregor Hohpe<br>
- <script type=text/javascript>
- var lm = new Date(document.lastModified);
- document.write(lm.toDateString());
- </script>
- </address>
- </body>
- </html>
|