glog - Google ロギング モジュールの C++ 実装

(C++ implementation of the Google logging module)

Created at: 2015-02-23 14:55:48
Language: C++
License: NOASSERTION

Google ログ ライブラリ

|Linux Github アクション| |Windows Github アクション| |macOS Github アクション| |総アラート| |言語グレード: C++| |コードコフ|

Google Logging (glog) は、アプリケーション レベルのロギングを実装する C++98 ライブラリです。このライブラリは、C++ スタイルのストリームとさまざまなヘルパー マクロに基づくログ API を提供します。

.. 役割:: cmake(コード) :言語: cmake

.. 役割:: cmd(コード) :言語: bash

.. 役割:: cpp(コード) :言語: cpp

.. 役割:: bazel(コード) :言語: starlark

入門

LOG
\ (<特定の __>) にストリーミングするだけで、メッセージをログに記録できます
severity level <#severity-levels>
。たとえば、

.. コード:: cpp

#include <glog/logging.h>

int main(int argc, char* argv[]) { // Google のロギング ライブラリを初期化します。google::InitGoogleLogging(argv[0]);

   // ...
   LOG(INFO) << "Found " << num_cookies << " cookies";

}

glog 機能とその使用方法の詳細な概要については、

user guide <#user-guide>
__を参照してください。

.. 目次:: 目次

ソースからのビルド

glog は、ソースからプロジェクトをコンパイルするための複数のビルド システムをサポートしています: 、、

Bazel <#bazel>
および
CMake <#cmake>
__
vcpkg <#vcpkg>

バゼル

To use glog within a project which uses the
`Bazel <https://bazel.build/>`__ build tool, add the following lines to
your ``WORKSPACE`` file:

.. code:: bazel

   load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

   http_archive(
       name = "com_github_gflags_gflags",
       sha256 = "34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf",
       strip_prefix = "gflags-2.2.2",
       urls = ["https://github.com/gflags/gflags/archive/v2.2.2.tar.gz"],
   )

   http_archive(
       name = "com_github_google_glog",
       sha256 = "122fb6b712808ef43fbf80f75c52a21c9760683dae470154f02bddfc61135022",
       strip_prefix = "glog-0.6.0",
       urls = ["https://github.com/google/glog/archive/v0.6.0.zip"],
   )

You can then add :bazel:`@com_github_google_glog//:glog` to the deps section
of a :bazel:`cc_binary` or :bazel:`cc_library` rule, and :code:`#include
<glog/logging.h>` to include it in your source code. Here’s a simple example:

.. code:: bazel

   cc_binary(
       name = "main",
       srcs = ["main.cc"],
       deps = ["@com_github_google_glog//:glog"],
   )

CMake

glog は、幅広いプラットフォームでプロジェクトをビルドするために使用できる CMake もサポートしています。CMake をまだインストールしていない場合は、CMake の

official website <http://www.cmake.org>
__ からダウンロードできます。

CMake は、選択したコンパイラ環境で使用できるネイティブの makefile またはビルド プロジェクトを生成することによって機能します。スタンドアロン プロジェクトとして CMake を使用して glog をビルドするか、別のプロジェクトの既存の CMake ビルドに組み込むことができます。

CMakeでglogをビルド^^^^^^^^^^^^^^^^^^^^^^^^

glog をスタンドアロン プロジェクトとしてビルドする場合、ビルド ツールとして GNU Make を使用する Unix ライクなシステムでは、典型的なワークフローは次のとおりです。

  1. ソースコードを入手して変更します。例: git を使用したクローン作成:

.. コード:: バッシュ

 git clone https://github.com/google/glog.git
 cd glog
  1. CMake を実行してビルド ツリーを構成します。

.. コード:: バッシュ

 cmake -S . -B build -G "Unix Makefiles"

CMake にはさまざまなジェネレーターが用意されており、デフォルトでは、環境に最も関連性の高いジェネレーターが選択されます。特定のバージョンの Visual Studio が必要な場合は、 :cmd: を使用し、使用可能なジェネレーター

cmake . -G <generator-name>
については :cmd: を参照してください。:cmd:を使用してネイティブ x64 ツールチェーンを要求するために使用できる
cmake --help
:cmd: も参照してください。
-T <toolset-name>
-T host=x64

  1. その後、生成されたファイルを使用してプロジェクトをコンパイルできます。

.. コード:: バッシュ

 cmake --build build
  1. ビルド ソフトウェアをテストします (オプション)。

.. コード:: バッシュ

 cmake --build build --target test
  1. ビルドされたファイルをインストールします (オプション)。

.. コード:: バッシュ

 cmake --build build --target install

CMake プロジェクトでの glog の使用 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

システムに glog がインストールされている場合は、CMake コマンド :cmake:

find_package
を使用して、次のように CMake プロジェクトで glog に対してビルドできます。

.. コード:: cmake

cmake_minimum_required (バージョン 3.16) プロジェクト (myproj バージョン 1.0)

find_package (glog 0.6.0 必須)

add_executable (myapp main.cpp) target_link_libraries (myapp glog::glog)

コンパイルの定義とオプションは、必要に応じてターゲットに自動的に追加されます。

glog を CMake プロジェクトに組み込む ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

CMake コマンド :cmake: を使用して、前の例の :cmake: 呼び出しを

add_subdirectory
:cmake: に置き換えることで、プロジェクトのサブディレクトリから直接 glog を含めることもできます。:cmake:ターゲットは、この場合、ライブラリ ターゲットの :cmake:ライブラリ ターゲットです。
find_package
add_subdirectory
glog::glog
ALIAS
glog

ここでも、コンパイル定義とオプションが必要に応じてターゲットに自動的に追加されます。

vcpkg

You can download and install glog using the `vcpkg
<https://github.com/Microsoft/vcpkg>`__ dependency manager:

.. code:: bash

   git clone https://github.com/Microsoft/vcpkg.git
   cd vcpkg
   ./bootstrap-vcpkg.sh
   ./vcpkg integrate install
   ./vcpkg install glog

The glog port in vcpkg is kept up to date by Microsoft team members and
community contributors. If the version is out of date, please create an
issue or pull request on the vcpkg repository.

User Guide
----------

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, customize the prefix attached to log messages, and more.

Following sections describe the functionality supported by glog. Please note
this description may not be complete but limited to the most useful ones. If you
want to find less common features, please check header files under `src/glog
<src/glog>`__ directory.

Severity Levels

次の重大度レベルのいずれかを (重大度の昇順で) 指定できます:

INFO
WARNING
ERROR
、および
FATAL
。メッセージをログ
FATAL
に記録すると、プログラムが終了します (メッセージがログに記録された後)。特定の重大度のメッセージは、その重大度のログ ファイルだけでなく、それより低い重大度のすべてのログ ファイルにも記録されることに注意してください。たとえば、重大度のメッセージは、重大度、、、およびの
FATAL
ログファイルに記録されます。
FATAL
ERROR
WARNING
INFO

重大度は、デバッグ モードでエラーを

DFATAL
ログに記録し
FATAL
ます (つまり、
NDEBUG
マクロが定義されていません) が、重大度を自動的に に下げることにより、本番環境でのプログラムの停止を回避し
ERROR
ます。

特に指定しない限り、glog はファイル名

/tmp/\<program name\>.\<hostname\>.\<user name\>.log.\<severity level\>.\<date\>-\<time\>.\<pid\>
(例:
/tmp/hello_world.example.com.hamaji.log.INFO.20080709-222411.10474
) に書き込みます。デフォルトでは、glog は、ログ ファイルに加えて、重大度レベル
ERROR
または
FATAL
標準エラー ( ) のログ メッセージをコピーします。
stderr

フラグの設定

Several flags influence glog’s output behavior. If the `Google gflags library
<https://github.com/gflags/gflags>`__ is installed on your machine, the build
system will automatically detect and use it, allowing you to pass flags on the
command line. For example, if you want to turn the flag :cmd:`--logtostderr` on,
you can start your application with the following command line:

.. code:: bash

   ./your_application --logtostderr=1

If the Google gflags library isn’t installed, you set flags via
environment variables, prefixing the flag name with ``GLOG_``, e.g.,

.. code:: bash

   GLOG_logtostderr=1 ./your_application

The following flags are most commonly used:

``logtostderr`` (``bool``, default=\ ``false``)
   Log messages to ``stderr`` instead of logfiles. Note: you can set
   binary flags to ``true`` by specifying ``1``, ``true``, or ``yes``
   (case insensitive). Also, you can set binary flags to ``false`` by
   specifying ``0``, ``false``, or ``no`` (again, case insensitive).

``stderrthreshold`` (``int``, default=2, which is ``ERROR``)
   Copy log messages at or above this level to stderr in addition to
   logfiles. The numbers of severity levels ``INFO``, ``WARNING``,
   ``ERROR``, and ``FATAL`` are 0, 1, 2, and 3, respectively.

``minloglevel`` (``int``, default=0, which is ``INFO``)
   Log messages at or above this level. Again, the numbers of severity
   levels ``INFO``, ``WARNING``, ``ERROR``, and ``FATAL`` are 0, 1, 2,
   and 3, respectively.

``log_dir`` (``string``, default="")
   If specified, logfiles are written into this directory instead of the
   default logging directory.

``v`` (``int``, default=0)
   Show all ``VLOG(m)`` messages for ``m`` less or equal the value of
   this flag. Overridable by :cmd:`--vmodule`. See `the section about
   verbose logging <#verbose-logging>`__ for more detail.

``vmodule`` (``string``, default="")
   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., ``gfs*`` 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 :cmd:`--v`.
   See also `the section about verbose logging <#verbose-logging>`__.

There are some other flags defined in logging.cc. Please grep the source
code for ``DEFINE_`` to see a complete list of all flags.

You can also modify flag values in your program by modifying global
variables ``FLAGS_*`` . Most settings start working immediately after
you update ``FLAGS_*`` . The exceptions are the flags related to
destination files. For example, you might want to set ``FLAGS_log_dir``
before calling :cpp:`google::InitGoogleLogging` . Here is an example:

.. code:: cpp

   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";

Conditional / Occasional Logging

特定の条件下でのみメッセージをログに記録したい場合があります。次のマクロを使用して、条件付きログを実行できます。

.. コード:: cpp

LOG_IF(INFO, num_cookies > 10) << "たくさんの Cookie を取得しました";

「Cookie が大量に取得されました」というメッセージは、変数

num_cookies
が 10 を超えた場合にのみログに記録されます。コード行が何度も実行される場合は、特定の間隔でのみメッセージをログに記録すると便利な場合があります。この種のロギングは、情報メッセージに最も役立ちます。

.. コード:: cpp

LOG_EVERY_N(INFO, 10) << "取得した" << google::COUNTER << "番目の Cookie";

上記の行は、実行された 1 回目、11 回目、21 回目、... 回のログ メッセージを出力します。

google::COUNTER
特別な値は、どの繰り返しが発生しているかを識別するために使用されることに注意してください。

次のマクロを使用して、条件付きログと不定期ログを組み合わせることができます。

.. コード:: cpp

LOG_IF_EVERY_N(INFO, (size > 1024), 10) << "取得した" << google::COUNTER << "th big cookie";

メッセージを n 回ごとに出力する代わりに、出力を最初の n 回に制限することもできます。

.. コード:: cpp

LOG_FIRST_N(INFO, 20) << "" << google::COUNTER << "th cookie" を取得しました;

実行された最初の 20 回のログ メッセージを出力します。ここでも、

google::COUNTER
識別子はどの繰り返しが発生しているかを示します。

また、時間に基づいて定期的にメッセージをログに記録することだけが望ましい場合もあります。たとえば、10 ミリ秒ごとにメッセージをログに記録するには、次のようにします。

.. コード:: cpp

LOG_EVERY_T(INFO, 0.01) << "クッキーを取得しました";

または 2.35 秒ごと:

.. コード:: cpp

LOG_EVERY_T(INFO, 2.35) << "クッキーを取得しました";

デバッグ モードのサポート

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.

.. code:: cpp

   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";


``CHECK`` Macros
~~~~~~~~~~~~~~~~

It is a good practice to check expected conditions in your program
frequently to detect errors as early as possible. The ``CHECK`` macro
provides the ability to abort the application when a condition is not
met, similar to the ``assert`` macro defined in the standard C library.

``CHECK`` aborts the application if a condition is not true. Unlike
``assert``, it is \*not\* controlled by ``NDEBUG``, so the check will be
executed regardless of compilation mode. Therefore, ``fp->Write(x)`` in
the following example is always executed:

.. code:: cpp

   CHECK(fp->Write(x) == 4) << "Write failed!";

There are various helper macros for equality/inequality checks -
``CHECK_EQ``, ``CHECK_NE``, ``CHECK_LE``, ``CHECK_LT``, ``CHECK_GE``,
and ``CHECK_GT``. They compare two values, and log a ``FATAL`` message
including the two values when the result is not as expected. The values
must have :cpp:`operator<<(ostream, ...)` defined.

You may append to the error message like so:

.. code:: cpp

   CHECK_NE(1, 2) << ": The world must be ending!";

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:

.. code:: cpp

   CHECK_EQ(string("abc")[1], ’b’);

The compiler reports an error if one of the arguments is a pointer and the other
is :cpp:`NULL`. To work around this, simply :cpp:`static_cast` :cpp:`NULL` to
the type of the desired pointer.

.. code:: cpp

   CHECK_EQ(some_ptr, static_cast<SomeType*>(NULL));

Better yet, use the ``CHECK_NOTNULL`` macro:

.. code:: cpp

   CHECK_NOTNULL(some_ptr);
   some_ptr->DoSomething();

Since this macro returns the given pointer, this is very useful in
constructor initializer lists.

.. code:: cpp

   struct S {
       S(Something* ptr) : ptr_(CHECK_NOTNULL(ptr)) {}
       Something* ptr_;
   };

Note that you cannot use this macro as a C++ stream due to this feature.
Please use ``CHECK_EQ`` described above to log a custom message before
aborting the application.

If you are comparing C strings (:cpp:`char *`), a handy set of macros performs
case sensitive as well as case insensitive comparisons - ``CHECK_STREQ``,
``CHECK_STRNE``, ``CHECK_STRCASEEQ``, and ``CHECK_STRCASENE``. The CASE versions
are case-insensitive. You can safely pass :cpp:`NULL` pointers for this macro. They
treat :cpp:`NULL` and any non-:cpp:`NULL` string as not equal. Two :cpp:`NULL`\
s are equal.

Note that both arguments may be temporary strings which are destructed
at the end of the current "full expression" (e.g.,
:cpp:`CHECK_STREQ(Foo().c_str(), Bar().c_str())` where ``Foo`` and ``Bar``
return C++’s :cpp:`std::string`).

The ``CHECK_DOUBLE_EQ`` macro checks the equality of two floating point
values, accepting a small error margin. ``CHECK_NEAR`` accepts a third
floating point argument, which specifies the acceptable error margin.

Verbose Logging
~~~~~~~~~~~~~~~

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 ``VLOG`` macro, which allows you to
define your own numeric logging levels. The :cmd:`--v` command line option
controls which verbose messages are logged:

.. code:: cpp

   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";

With ``VLOG``, the lower the verbose level, the more likely messages are to be
logged. For example, if :cmd:`--v==1`, ``VLOG(1)`` will log, but ``VLOG(2)``
will not log. This is opposite of the severity level, where ``INFO`` is 0, and
``ERROR`` is 2. :cmd:`--minloglevel` of 1 will log ``WARNING`` and above. Though
you can specify any integers for both ``VLOG`` macro and :cmd:`--v` flag, the
common values for them are small positive integers. For example, if you write
``VLOG(0)``, you should specify :cmd:`--v=-1` or lower to silence it. This is
less useful since we may not want verbose logs by default in most cases. The
``VLOG`` macros always log at the ``INFO`` log level (when they log at all).

Verbose logging can be controlled from the command line on a per-module
basis:

.. code:: bash

   --vmodule=mapreduce=2,file=1,gfs*=3 --v=0

will:

(a) Print ``VLOG(2)`` and lower messages from mapreduce.{h,cc}
(b) Print ``VLOG(1)`` and lower messages from file.{h,cc}
(c) Print ``VLOG(3)`` and lower messages from files prefixed with "gfs"
(d) Print ``VLOG(0)`` and lower messages from elsewhere

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 `command line flags <#setting-flags>`__.

There’s also ``VLOG_IS_ON(n)`` "verbose level" condition macro. This
macro returns true when the :cmd:`--v` is equal or greater than ``n``. To
be used as

.. code:: cpp

   if (VLOG_IS_ON(2)) {
       // do some logging preparation and logging
       // that can’t be accomplished with just VLOG(2) << ...;
   }

Verbose level condition macros ``VLOG_IF``, ``VLOG_EVERY_N`` and
``VLOG_IF_EVERY_N`` behave analogous to ``LOG_IF``, ``LOG_EVERY_N``,
``LOF_IF_EVERY``, but accept a numeric verbosity level as opposed to a
severity level.

.. code:: cpp

   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;


Custom Log Prefix Format

glog は、ユーザー提供のコールバックを受信して​​ログ メッセージに付加されるプレフィックスの形式を変更し、そのような文字列を生成するために使用することをサポートしています。

WITH_CUSTOM_PREFIX
この機能は、フラグによってコンパイル時に有効にする必要があります。

ログ エントリごとに

LogMessageInfo
、重大度、ファイル名、行番号、スレッド ID、およびイベントの時刻を含む構造体を使用して、コールバックが呼び出されます。また、出力ストリームへの参照も与えられ、その内容は最終ログ行の実際のメッセージの前に追加されます。

例えば:

.. コード:: cpp

/* This function writes a prefix that matches glog's default format.
 * (The third parameter can be used to receive user-supplied data, and is
 * NULL by default.)
 */
void CustomPrefix(std::ostream &s, const LogMessageInfo &l, void*) {
   s << l.severity[0]
   << setw(4) << 1900 + l.time.year()
   << setw(2) << 1 + l.time.month()
   << setw(2) << l.time.day()
   << ' '
   << setw(2) << l.time.hour() << ':'
   << setw(2) << l.time.min()  << ':'
   << setw(2) << l.time.sec() << "."
   << setw(6) << l.time.usec()
   << ' '
   << setfill(' ') << setw(5)
   << l.thread_id << setfill('0')
   << ' '
   << l.filename << ':' << l.line_number << "]";
}

の使用を有効にするには

CustomPrefix()
、初期化中に glog にポインターを渡すだけです
InitGoogleLogging(argv[0], &CustomPrefix);

オプションで、

InitGoogleLogging()
型の 3 番目の引数を取り
void*
、コールバック関数に渡します。

失敗シグナルハンドラ

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 :cpp:`google::InstallFailureSignalHandler()`.
The following is an example of output from the signal handler.

::

   *** 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)

By default, the signal handler writes the failure dump to the standard
error. You can customize the destination by :cpp:`InstallFailureWriter()`.

Performance of Messages

glog が提供する条件付きロギング マクロ (例: 、、

CHECK
など ) は慎重に実装されており、条件が false の場合は右辺の式を実行しません。したがって、次のチェックによってアプリケーションのパフォーマンスが犠牲になることはありません。
LOG_IF
VLOG

.. コード:: cpp

CHECK(obj.ok) << obj.CreatePrettyFormattedStringButVerySlow();

ユーザー定義の障害関数

``FATAL`` severity level messages or unsatisfied ``CHECK`` condition
terminate your program. You can change the behavior of the termination
by :cpp:`InstallFailureFunction`.

.. code:: cpp

   void YourFailureFunction() {
     // Reports something...
     exit(EXIT_FAILURE);
   }

   int main(int argc, char* argv[]) {
     google::InstallFailureFunction(&YourFailureFunction);
   }

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).

Raw Logging
~~~~~~~~~~~

The header file ``<glog/raw_logging.h>`` 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 `src/glog/raw_logging.h.in
<src/glog/raw_logging.h.in>`__ for detail.

Google Style ``perror()``
~~~~~~~~~~~~~~~~~~~~~~~~~

``PLOG()`` and ``PLOG_IF()`` and ``PCHECK()`` behave exactly like their
``LOG*`` and ``CHECK`` equivalents with the addition that they append a
description of the current state of errno to their output lines. E.g.

.. code:: cpp

   PCHECK(write(1, NULL, 2) >= 0) << "Write NULL failed";

This check fails with the following error message.

::

   F0825 185142 test.cc:22] Check failed: write(1, NULL, 2) >= 0 Write NULL failed: Bad address [14]

Syslog
~~~~~~

``SYSLOG``, ``SYSLOG_IF``, and ``SYSLOG_EVERY_N`` 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.

Strip Logging Messages
~~~~~~~~~~~~~~~~~~~~~~

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:

If your application has code like this:

.. code:: cpp

   #define GOOGLE_STRIP_LOG 1    // this must go before the #include!
   #include <glog/logging.h>

The compiler will remove the log messages whose severities are less than
the specified integer value. Since ``VLOG`` logs at the severity level
``INFO`` (numeric value ``0``), setting ``GOOGLE_STRIP_LOG`` to 1 or
greater removes all log messages associated with ``VLOG``\ s as well as
``INFO`` log statements.

Automatically Remove Old Logs

ログ クリーナーを有効にするには:

.. コード:: cpp

google::EnableLogCleaner(3); // ログを 3 日間保持します

そして、glog は、フラッシュが実行されるたびに期限切れのログがあるかどうかをチェックします。この例では、最終変更時間が 3 日を超えるプロジェクトのログ ファイルはすべて unlink() されます。

この機能はいつでも無効にできます (有効になっている場合)。

.. コード:: cpp

google::DisableLogCleaner();

Windows ユーザー向けの注意事項

glog defines a severity level ``ERROR``, which is also defined in
``windows.h`` . You can make glog not define ``INFO``, ``WARNING``,
``ERROR``, and ``FATAL`` by defining ``GLOG_NO_ABBREVIATED_SEVERITIES``
before including ``glog/logging.h`` . Even with this macro, you can
still use the iostream like logging facilities:

.. code:: cpp

   #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";

However, you cannot use ``INFO``, ``WARNING``, ``ERROR``, and ``FATAL``
anymore for functions defined in ``glog/logging.h`` .

.. code:: cpp

   #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);

If you don’t need ``ERROR`` defined by ``windows.h``, there are a couple
of more workarounds which sometimes don’t work:

-  ``#define WIN32_LEAN_AND_MEAN`` or ``NOGDI`` **before** you
   ``#include windows.h``.
-  ``#undef ERROR`` **after** you ``#include windows.h`` .

See `this
issue <http://code.google.com/p/google-glog/issues/detail?id=33>`__ for
more detail.


Installation Notes for 64-bit Linux Systems

64 ビット システムの glibc 組み込みスタック アンワインダーには、glog に関するいくつかの問題があります。(特に、 :cpp: を使用している場合

InstallFailureSignalHandler()
、シグナルは malloc の途中で発生し、スタック アンワインダーを呼び出すときにいくつかの malloc 関連のロックを保持します。組み込みのスタック アンワインダーは malloc を再帰的に呼び出す場合があり、これには必要な場合があります。すでに保持しているロックを取得するスレッド: デッドロック。)

そのため、64 ビット システムを使用していて :cpp: が必要な場合は、 Google glog を構成またはインストールする前に

InstallFailureSignalHandler()
インストールすることを強くお勧め します。
libunwind
libunwind を見つけることができます
here <http://download.savannah.nongnu.org/releases/libunwind/libunwind-snap-070410.tar.gz>
__.

既に

libunwind
インストールしている場合でも、最新バージョンを取得するには、おそらくスナップショットからインストールする必要があります。

注意: 上記の URL から libunwind をインストールする場合、バイナリを glog に静的にリンクしようとすると問題が発生する可能性があることに注意してください

gcc -static -lgcc_eh ...
。これは、
libunwind
libgcc
が同じ C++ 例外処理 API を実装しているにもかかわらず、一部のプラットフォームでは実装が異なるためです。これは ia64 では問題にならない可能性がありますが、x86-64 では問題になる可能性があります。

また、バイナリを静的にリンクする場合は、必ず

-Wl,--eh-frame-hdr
リンカー オプションに :cmd: を追加してください。これは
libunwind
、スタックの巻き戻しに必要なコンパイラによって生成された情報を見つけるために必要です。

ただし、 :cmd: を使用する

-static
ことはめったにないため、これが影響することがわかっていない限り、おそらく影響はありません。

libunwind をインストールできない場合、またはインストールしたくない場合でも、2 種類のスタックアンワインダーを試すことができます: 1. glibc 組み込みスタックアンワインダーと 2. フレームポインターベースのスタックアンワインダー。

  1. すでに述べたように、glibc の unwinder にはデッドロックの問題があります。ただし、:cpp: を使用しない場合、

    InstallFailureSignalHandler()
    またはまれにデッドロックが発生する可能性を気にしない場合は、このスタック アンワインダーを使用できます。オプションを指定せ
    libunwind
    ず、システムで検出されない場合、configure スクリプトはデフォルトでこのアンワインダーを選択します。

  2. フレーム ポインター ベースのスタック アンワインダーでは、アプリケーション、glog ライブラリ、および libc などのシステム ライブラリをすべてフレーム ポインターでコンパイルする必要があります。これはx86-64 のデフォルトではありません。

貢献する方法

このプロジェクトへのパッチと貢献を歓迎します。従う必要のある小さなガイドラインがいくつかあります。

寄稿者ライセンス契約 (CLA)

Contributions to any Google project must be accompanied by a Contributor
License Agreement. This is not a copyright **assignment**, it simply
gives Google permission to use and redistribute your contributions as
part of the project.

* If you are an individual writing original source code and you’re sure
  you own the intellectual property, then you’ll need to sign an
  `individual
  CLA <https://developers.google.com/open-source/cla/individual>`__.
* If you work for a company that wants to allow you to contribute your
  work, then you’ll need to sign a `corporate
  CLA <https://developers.google.com/open-source/cla/corporate>`__.

You generally only need to submit a CLA once, so if you’ve already
submitted one (even if it was for a different project), you probably
don’t need to do it again.

Once your CLA is submitted (or if you already submitted one for another
Google project), make a commit adding yourself to the
`AUTHORS <./AUTHORS>`__ and `CONTRIBUTORS <./CONTRIBUTORS>`__ files. This
commit can be part of your first `pull
request <https://help.github.com/articles/creating-a-pull-request>`__.

Submitting a Patch
~~~~~~~~~~~~~~~~~~

1. It’s generally best to start by opening a new issue describing the
   bug or feature you’re intending to fix. Even if you think it’s
   relatively minor, it’s helpful to know what people are working on.
   Mention in the initial issue that you are planning to work on that
   bug or feature so that it can be assigned to you.
2. Follow the normal process of
   `forking <https://help.github.com/articles/fork-a-repo>`__ the
   project, and setup a new branch to work in. It’s important that each
   group of changes be done in separate branches in order to ensure that
   a pull request only includes the commits related to that bug or
   feature.
3. Do your best to have `well-formed commit
   messages <http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html>`__
   for each change. This provides consistency throughout the project,
   and ensures that commit messages are able to be formatted properly by
   various git tools.
4. Finally, push the commits to your fork and submit a `pull
   request <https://help.github.com/articles/creating-a-pull-request>`__.


.. |Linux Github actions| image:: https://github.com/google/glog/actions/workflows/linux.yml/badge.svg
   :target: https://github.com/google/glog/actions
.. |Windows Github actions| image:: https://github.com/google/glog/actions/workflows/windows.yml/badge.svg
   :target: https://github.com/google/glog/actions
.. |macOS Github actions| image:: https://github.com/google/glog/actions/workflows/macos.yml/badge.svg
   :target: https://github.com/google/glog/actions
.. |Total alerts| image:: https://img.shields.io/lgtm/alerts/g/google/glog.svg?logo=lgtm&logoWidth=18
   :target: https://lgtm.com/projects/g/google/glog/alerts/
.. |Language grade: C++| image:: https://img.shields.io/lgtm/grade/cpp/g/google/glog.svg?logo=lgtm&logoWidth=18)
   :target: https://lgtm.com/projects/g/google/glog/context:cpp
.. |Codecov| image:: https://codecov.io/gh/google/glog/branch/master/graph/badge.svg?token=8an420vNju
   :target: https://codecov.io/gh/google/glog