"logging" --- Python 用のログ記録手段
*************************************

**ソースコード:** Lib/logging/__init__.py


Important
^^^^^^^^^

このページには、リファレンス情報だけが含まれています。チュートリアルは
、以下のページを参照してください

* 基本チュートリアル

* 上級チュートリアル

* ロギングクックブック

======================================================================

このモジュールは、アプリケーションやライブラリのための柔軟なエラーログ
記録 (logging) システムを実装するための関数やクラスを定義しています。

標準ライブラリモジュールとしてログ記録 API が提供される利点は、すべて
の Python モジュールがログ記録に参加できることであり、これによってあな
たが書くアプリケーションのログにサードパーティーのモジュールが出力する
メッセージを含ませることができます。

以下は慣用的な使い方の単純な例です:

   # myapp.py
   import logging
   import mylib
   logger = logging.getLogger(__name__)

   def main():
       logging.basicConfig(filename='myapp.log', level=logging.INFO)
       logger.info('Started')
       mylib.do_something()
       logger.info('Finished')

   if __name__ == '__main__':
       main()

   # mylib.py
   import logging
   logger = logging.getLogger(__name__)

   def do_something():
       logger.info('Doing something')

*myapp.py* を実行すれば、*myapp.log* でログが確認できます:

   INFO:__main__:Started
   INFO:mylib:Doing something
   INFO:__main__:Finished

この慣用的な使い方における重要な特色は、大部分のコードは
"getLogger(__name__)" で単にモジュールレベルのロガーを作るだけで、その
ロガーを必要なロギングに使えるということです。これは簡潔であると同時に
、下位のコードにおいて、必要に応じてきめ細やかな制御を可能にしています
。モジュールレベルのロガーに対するログメッセージは、最終的にルートロガ
ーとして知られる最上位のロガーに達するまで順次転送されます。ロギングに
対するこのようなアプローチは、階層的ロギングとして知られています。

ロギングを有用なものとするためには、用途に応じて構成する必要があります
: ログレベルの設定や各ロガーの出力先から、潜在的には特定のモジュールに
対する振る舞いの変更などを、しばしばコマンドライン引数かアプリケーショ
ンの構成の一部として。上記の例を含めて、ほとんどの場合ではルートロガー
のみを構成するだけで十分です。なぜならモジュールレベルの全ての下位のロ
ガーは、全てのメッセージを最終的にルートロガーのハンドラに転送するから
です。 "basicConfig()" は、多くのユースケースを上手に扱うことのできる
簡便なルートロガーの構成方法を提供します。

このモジュールは、多くの機能性と柔軟性を提供します。ロギングに慣れてい
ないなら、使い方を理解する最良の方法はチュートリアルを読むことです (**
右上のリンクを参照してください**)。

モジュールで定義されている基本的なクラスと、その属性およびメソッドを以
下に列挙します。

* ロガーは、アプリケーションコードが直接使うインターフェースを公開しま
  す。

* ハンドラは、(ロガーによって生成された) ログ記録を適切な送信先に送り
  ます。

* フィルタは、どのログ記録を出力するかを決定する、きめ細かい機能を提供
  します。

* フォーマッタは、ログ記録が最終的に出力されるレイアウトを指定します。


ロガーオブジェクト
==================

ロガーには以下のような属性とメソッドがあります。 ロガーを直接インスタ
ンス化することは *絶対に* してはならず、常にモジュール関数
"logging.getLogger(name)" を介してインスタンス化することに注意してくだ
さい。 同じ name で "getLogger()" を複数回呼び出すと、常に同じロガー・
オブジェクトへの参照が返されます。

"name" は、潜在的に "foo.bar.baz" のようなピリオドで区切られた階層的な
値です (ただし、たとえば "foo" のような単純な値も可能です)。階層構造の
下位にあるロガーは、上位のロガーの子になります。たとえば "foo" という
名前のロガーに対して、 "foo.bar"、 "foo.bar.baz"、 "foo.bam" という名
前のロガーは全て "foo" の子孫です。さらに、全てのロガーはルートロガー
の子孫です。ロガー名の階層構造は Python パッケージの階層構造に類似して
います。また、推奨される構築方法である "logging.getLogger(__name__)"
を使ってモジュール単位でロガーを構築すれば、パッケージの階層構造とロガ
ーの階層構造は同一になります。なぜなら、モジュールの中で、 "__name__"
は Python パッケージの名前空間におけるモジュール名だからです。

class logging.Logger

   name

      ロガーの名前です。また、ロガーを取得するために "getLogger()" を
      呼び出すときに渡された値です。

      注釈:

        この属性は読み出し専用として扱われるべきです。

   level

      "setLevel()" メソッドで設定された、このロガーのしきい値です。

      注釈:

        この属性を直接設定しないでください -  "setLevel()" は渡された
        レベルをチェックする機能を持っていますので、常にこのメソッドを
        使うようにしてください。

   parent

      このロガーの親にあたるロガーです。名前空間の階層構造で上位にあた
      るロガーのインスタンス化により、親ロガーは変わる可能性があります
      。

      注釈:

        この値は読み出し専用として取り扱われるべきです。

   propagate

      この属性が真と評価された場合、このロガーに記録されたイベントは、
      このロガーに取り付けられた全てのハンドラに加え、上位 (祖先) ロガ
      ーのハンドラにも渡されます。 メッセージは、祖先ロガーのハンドラ
      に直接渡されます - 今問題にしている祖先ロガーのレベルもフィルタ
      も、どちらも考慮されません。

      この値の評価結果が偽になる場合、ロギングメッセージは祖先ロガーの
      ハンドラに渡されません。

      具体的な例で説明します: "A.B.C" という名前のロガーの propagate
      属性が真と評価された場合、
      "logging.getLogger('A.B.C').error(...)" のようなメソッドの呼び出
      しを通じて "A.B.C" に記録された全てのイベントは、 [ログレベルと
      フィルタの設定を満たした場合に限り] 最初に "A.B.C" に接続された
      ハンドラに渡され、その後 "A.B", "A" という名前のロガー、そしてル
      ートロガーという順番で各ロガーに接続されたハンドラに渡されます。
      この連鎖構造において "A.B.C", "A.B", "A" のいずれかの
      "propagate" 属性が偽に設定された場合、そのロガーがイベントを処理
      する最後のロガーとなり、その時点でイベントの伝播は止まります。

      コンストラクタはこの属性を "True" に設定します。

      注釈:

        ハンドラを、あるロガー *と* その祖先のロガーに接続した場合、同
        一レコードが複数回発行される場合があります。一般的に、ハンドラ
        を複数のロガーに接続する必要はありません。propagate 設定が
        "True" のままになっていれば、ロガーの階層において最上位にある
        適切なロガーにハンドラを接続するだけで、そのハンドラは全ての子
        孫ロガーが記録する全てのイベントを確認することができます。一般
        的なシナリオでは、ハンドラをルートロガーに対してのみ接続し、残
        りは propagate にすべて委ねます。

   handlers

      このロガーインスタンスに直接接続されているハンドラのリストです。

      注釈:

        この属性は読み出し専用として取り扱われるべきです; 通常この属性
        は "addHandler()" と "removeHandler()" の2つのメソッドを介して
        変更されます。これらのメソッドはスレッドセーフな処理を保証する
        ためにロックを活用します。

   disabled

      この属性は、いかなるイベントの処理も作動しないようにします。イニ
      シャライザはこの属性に "False" を設定します。また、この属性はロ
      ギングを設定するコードによってのみ変更されます。

      注釈:

        この属性は読み出し専用として扱われるべきです。

   setLevel(level)

      このロガーの閾値を *level* に設定します。 *level* よりも深刻でな
      いログメッセージは無視されます; 深刻さが *level* 以上のログメッ
      セージは、ハンドラのレベルが *level* より上に設定されていない限
      り、このロガーに取り付けられているハンドラによって投げられます。

      ロガーが生成された際、レベルは "NOTSET" (これによりすべてのメッ
      セージについて、ロガーがルートロガーであれば処理される、そうでな
      くてロガーが非ルートロガーの場合には親ロガーに委譲させる) に設定
      されます。 ルートロガーは "WARNING" レベルで生成されることに注意
      してください。

      「親ロガーに委譲」という用語の意味は、もしロガーのレベルが
      NOTSET ならば、祖先ロガーの系列の中を NOTSET 以外のレベルの祖先
      を見つけるかルートに到達するまで辿っていく、ということです。

      もし NOTSET 以外のレベルの祖先が見つかったなら、その祖先のレベル
      が探索を開始したロガーの実効レベルとして扱われ、ログイベントがど
      のように処理されるかを決めるのに使われます。

      ルートに到達した場合、ルートのレベルが NOTSET ならばすべてのメッ
      セージは処理されます。そうでなければルートのレベルが実効レベルと
      して使われます。

      レベルの一覧については ロギングレベル を参照してください。

      バージョン 3.2 で変更: *level* パラメータは、 "INFO" のような整
      数定数の代わりに 'INFO' のようなレベルの文字列表現も受け付けるよ
      うになりました。ただし、レベルは内部で整数として保存されますし、
      "getEffectiveLevel()" や "isEnabledFor()" といったメソッドは、整
      数を返し、また渡されるものと期待します。

   isEnabledFor(level)

      深刻度が *lvl* のメッセージが、このロガーで処理されることになっ
      ているかどうかを示します。このメソッドはまず、
      "logging.disable(level)" で設定されるモジュールレベルの深刻度レ
      ベルを調べ、次にロガーの実効レベルを "getEffectiveLevel()" で調
      べます。

   getEffectiveLevel()

      このロガーの実効レベルを示します。 "NOTSET" 以外の値が
      "setLevel()" で設定されていた場合、その値が返されます。そうでな
      い場合、 "NOTSET" 以外の値が見つかるまでロガーの階層をルートロガ
      ーの方向に追跡します。見つかった場合、その値が返されます。返され
      る値は整数で、典型的には "logging.DEBUG", "logging.INFO" 等のう
      ち一つです。

   getChild(suffix)

      このロガーの子であるロガーを、接頭辞によって決定し、返します。従
      って、"logging.getLogger('abc').getChild('def.ghi')" は、
      "logging.getLogger('abc.def.ghi')" によって返されるのと同じロガ
      ーを返すことになります。これは簡便なメソッドで、親ロガーがリテラ
      ルでなく "__name__" などを使って名付けられているときに便利です。

      Added in version 3.2.

   getChildren()

      このロガーの直接の子であるロガーの集合を返します。したがって、た
      とえば "logging.getLogger().getChildren()" は "foo" や "bar" と
      いった名前のロガーを含む集合を返すかもしれませんが、 "foo.bar"
      という名前のロガーは戻り値の集合には含まれません。同様に、
      "logging.getLogger('foo').getChildren()" は "foo.bar" という名前
      のロガーを含む集合を返すかもしれませんが、 "foo.bar.baz" のよう
      な名前のロガーは戻り値の集合には含まれません。

      Added in version 3.12.

   debug(msg, *args, **kwargs)

      レベル "DEBUG" のメッセージをこのロガーで記録します。 *msg* はメ
      ッセージの書式文字列で、 *args* は *msg* に文字列書式化演算子を
      使って取り込むための引数です。 (これは、書式化文字列の中でキーワ
      ードを使い、引数として単一の辞書を渡すことができる、ということを
      意味します。) *args* が提供されない場合は *msg* の%フォーマット
      は実行されません。

      *kwargs* のうち、 *exc_info*, *stack_info*, *stacklevel*,
      *extra* という4つのキーワード引数の中身を調べます。

      *exc_info* は、この値の評価値が false でない場合、例外情報がロギ
      ングメッセージに追加されます。もし例外情報をあらわすタプル
      ("sys.exc_info()" 関数によって戻されるフォーマットにおいて)、ま
      たは、例外情報をあらわすインスタンスが与えられていれば、それが使
      用されることになります。それ以外の場合には、 "sys.exc_info()" を
      呼び出して例外情報を取得します。

      2つ目の省略可能なキーワード引数は *stack_info* で、デフォルトは
      "False" です。真の場合、実際のロギング呼び出しを含むスタック情報
      がロギングメッセージに追加されます。これは *exc_info* 指定によっ
      て表示されるスタック情報と同じものではないことに注意してください
      : 前者はカレントスレッド内での、一番下からロギング呼び出しまでの
      スタックフレームですが、後者は例外に呼応して、例外ハンドラが見つ
      かるところまで巻き戻されたスタックフレームの情報です。

      *exc_info* とは独立に *stack_info* を指定することもできます (例
      えば、例外が上げられなかった場合でも、コード中のある地点にどのよ
      うに到着したかを単に示すために)。スタックフレームは、次のような
      ヘッダー行に続いて表示されます:

         Stack (most recent call last):

      これは、例外フレームを表示する場合に使用される "Traceback (most
      recent call last):" を模倣します。

      3番目のオプションキーワード引数は *stacklevel* で、デフォルトは
      "1" です。もしこれが1よりも大きい場合は、 "LogRecord" 内で行番号
      と関数名を算出する時に、指定されたスタックフレームの数をスキップ
      します。これはログヘルパー内部で使われる場合、関数名、ファイル名
      、行番号はそのヘルパーの情報ではなく、そのヘルパーを呼び出した呼
      び出し元のものになります。このパラメータの名前は "warnings" モジ
      ュールと同じものになります。

      4番目のキーワード引数は *extra* で、ロギングイベントの際に作られ
      る "LogRecord" の "__dict__" 属性に、ユーザー定義の属性を追加す
      るための辞書を渡すのに使うことができます。これら追加の属性は、好
      きなように使うことができます。たとえば、それらをログメッセージに
      埋め込むことができます。使用例:

         FORMAT = '%(asctime)s %(clientip)-15s %(user)-8s %(message)s'
         logging.basicConfig(format=FORMAT)
         d = {'clientip': '192.168.0.1', 'user': 'fbloggs'}
         logger = logging.getLogger('tcpserver')
         logger.warning('Protocol problem: %s', 'connection reset', extra=d)

      これは以下のような出力を行います

         2006-02-08 22:20:02,165 192.168.0.1 fbloggs  Protocol problem: connection reset

      *extra* に渡される辞書のキーはロギングシステムで使われているもの
      と衝突してはいけません。 (ロギングシステムが使うキーの詳細につい
      ては LogRecord 属性 の節を参照してください。)

      これらの属性をログメッセージに使うことにしたなら、少し注意が必要
      です。上の例では、 'clientip' と 'user' が "LogRecord" の属性辞
      書に含まれていることを期待した書式文字列で "Formatter" がセット
      アップされています。もしこれらが欠けていると、書式化例外が発生し
      てしまうためメッセージはログに残りません。したがってこの場合、常
      にこれらのキーを含む *extra* 辞書を渡す必要があります。

      このようなことは煩わしいかもしれませんが、この機能は限定された場
      面で使われるように意図しているものなのです。たとえば同じコードが
      いくつものコンテキストで実行されるマルチスレッドのサーバで、興味
      のある条件が現れるのがそのコンテキストに依存している (上の例で言
      えば、リモートのクライアント IP アドレスや認証されたユーザ名など
      )、というような場合です。そういった場面では、それ用の
      "Formatter" が特定の "Handler" と共に使われるというのはよくある
      ことです。

      このロガー (および "Logger.propagate" 属性を考慮した上で実効的に
      イベントが伝播する祖先のロガー) にハンドラが接続されていない場合
      、メッセージは "lastResort" に設定されたハンドラーに送られます。

      バージョン 3.2 で変更: *stack_info* パラメータが追加されました。

      バージョン 3.5 で変更: *exc_info* パラメータは例外インスタンスを
      受け入れることが可能です。

      バージョン 3.8 で変更: *stacklevel* 引数が追加されました。

   info(msg, *args, **kwargs)

      レベル "INFO" のメッセージをこのロガーで記録します。引数は
      "debug()" と同じように解釈されます。

   warning(msg, *args, **kwargs)

      レベル "WARNING" のメッセージをこのロガーで記録します。引数は
      "debug()" と同じように解釈されます。

      注釈:

        "warning" と機能的に等価な古いメソッド "warn" があります。
        "warn" は廃止予定なので使わないでください - 代わりに "warning"
        を使ってください。

   error(msg, *args, **kwargs)

      レベル "ERROR" のメッセージをこのロガーで記録します。引数は
      "debug()" と同じように解釈されます。

   critical(msg, *args, **kwargs)

      レベル "CRITICAL" のメッセージをこのロガーで記録します。引数は
      "debug()" と同じように解釈されます。

   log(level, msg, *args, **kwargs)

      整数で表したレベル *level* のメッセージをこのロガーで記録します
      。その他の引数は "debug()" と同じように解釈されます。

   exception(msg, *args, **kwargs)

      レベル "ERROR" のメッセージをこのロガーで記録します。引数は
      "debug()" と同じように解釈されます。例外情報がログメッセージに追
      加されます。このメソッドは例外ハンドラからのみ呼び出されるべきで
      す。

   addFilter(filter)

      指定されたフィルタ *filter* をこのロガーに追加します。

   removeFilter(filter)

      指定されたフィルタ *filter* をこのロガーから取り除きます。

   filter(record)

      レコードに対してこのロガーのフィルタを適用し、レコードが処理され
      るべき場合に "True" を返します。フィルタのいずれかの値が偽を返す
      まで、それらは順番に試されていきます。いずれも偽を返さなければ、
      レコードは処理される(ハンドラに渡される)ことになります。ひとつで
      も偽を返せば、発生したレコードはもはや処理されることはありません
      。

   addHandler(hdlr)

      指定されたハンドラ *hdlr* をこのロガーに追加します。

   removeHandler(hdlr)

      指定されたハンドラ *hdlr* をこのロガーから取り除きます。

   findCaller(stack_info=False, stacklevel=1)

      呼び出し元のソースファイル名と行番号を調べます。ファイル名と行番
      号、関数名、スタック情報を 4 要素のタプルで返します。
      *stack_info* が "True" でなければ、スタック情報は "None" が返さ
      れます。

      *stacklevel* パラメータは "debug()" や他のAPIを呼び出すコードか
      ら渡されます。もしこれが1よりも大きい場合は、その超過分は返す値
      を決定する前にスタックフレームをスキップする数として利用されます
      。これは通常、ログAPIをヘルパーやラッパー経由で呼び出す場合に便
      利です。こうすることで、イベントログに記録される情報はヘルパーや
      ラッパーのコードではなく、それらを呼び出しているコードのものとな
      ります。

   handle(record)

      レコードを、このロガーおよびその上位ロガー (ただし *propagate*
      の値が false になったところまで) に関連付けられているすべてのハ
      ンドラに渡して処理します。このメソッドは、ローカルで生成されたレ
      コードだけでなく、ソケットから受信した unpickle されたレコードに
      対しても同様に用いられます。 "filter()" によって、ロガーレベルで
      のフィルタが適用されます。

   makeRecord(name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)

      このメソッドは、特殊な "LogRecord" インスタンスを生成するために
      サブクラスでオーバライドできるファクトリメソッドです。

   hasHandlers()

      このロガーにハンドラが設定されているかどうかを調べます。 そのた
      めに、このロガーとロガー階層における祖先からハンドラを探します。
      ハンドラが見つかれば "True" 、そうでなければ "False" を返します
      。 このメソッドは、'propagate' 属性が偽に設定されたロガーを見つ
      けると、さらに上位の探索をやめます。そのロガーが、ハンドラが存在
      するかどうかチェックされる最後のロガーになります。

      Added in version 3.2.

   バージョン 3.7 で変更: ロガーの pickle 化と unpickle 化ができるよう
   になりました。


ロギングレベル
==============

ログレベルの数値は以下の表のように与えられています。これらは基本的に自
分でレベルを定義したい人のためのもので、定義するレベルを既存のレベルの
間に位置づけるためには具体的な値が必要になります。もし数値が他のレベル
と同じだったら、既存の値は上書きされその名前は失われます。

+-------------------------+-----------------+---------------------------------------+
| レベル                  | 数値            | どういう意味か / いつ使用するべきか   |
|=========================|=================|=======================================|
| logging.NOTSET          | 0               | ロガーに対してこのレベルが設定された  |
|                         |                 | 場合、実際のログレベルは祖先のロガ ー |
|                         |                 | を参照して決めることを意味します。実  |
|                         |                 | 効ログレベルも "NOTSET" となった 場合 |
|                         |                 | は、全てのイベントが記録されます。ハ  |
|                         |                 | ンドラーに対してこのレベルが設 定され |
|                         |                 | た場合、全てのイベントが処理されます  |
|                         |                 | 。                                    |
+-------------------------+-----------------+---------------------------------------+
| logging.DEBUG           | 10              | 詳細情報。典型的には、問題が発生した  |
|                         |                 | 際に原因を突き止めようとする開発者 向 |
|                         |                 | けの情報。                            |
+-------------------------+-----------------+---------------------------------------+
| logging.INFO            | 20              | 想定された通りのことが起こったことの  |
|                         |                 | 確認。                                |
+-------------------------+-----------------+---------------------------------------+
| logging.WARNING         | 30              | 想定外の事象、または近い将来に問題が  |
|                         |                 | 起きる可能性 (たとえば 'disk space    |
|                         |                 | low' すなわちディスク空き容量の低下)  |
|                         |                 | の表示。ソフトウエアは引き続き期 待通 |
|                         |                 | りに動作している状態。                |
+-------------------------+-----------------+---------------------------------------+
| logging.ERROR           | 40              | より重大な問題により、ソフトウェアが  |
|                         |                 | ある機能を実行できないこと。          |
+-------------------------+-----------------+---------------------------------------+
| logging.CRITICAL        | 50              | プログラム自体が実行を続けられないこ  |
|                         |                 | とを表す、重大なエラー。              |
+-------------------------+-----------------+---------------------------------------+


ハンドラオブジェクト
====================

ハンドラ (Handler) は以下の属性とメソッドを持ちます。 "Handler" は直接
インスタンス化されることはありません; このクラスはより便利なサブクラス
の基底クラスとして働きます。しかしながら、サブクラスにおける
"__init__()" メソッドでは、 "Handler.__init__()" を呼び出す必要があり
ます。

class logging.Handler

   __init__(level=NOTSET)

      レベルを設定して、 "Handler" インスタンスを初期化します。空のリ
      ストを使ってフィルタを設定し、 I/O 機構へのアクセスを直列化する
      ために ("createLock()" を使って) ロックを生成します。

   createLock()

      スレッドセーフでない背後の I/O 機能に対するアクセスを直列化する
      ために用いられるスレッドロック (thread lock) を初期化します。

   acquire()

      "createLock()" で生成されたスレッドロックを獲得します。

   release()

      "acquire()" で獲得したスレッドロックを解放します。

   setLevel(level)

      このハンドラに対する閾値を *level* に設定します。 *level* よりも
      深刻でないログメッセージは無視されます。 ハンドラが生成された際
      、レベルは "NOTSET" (すべてのメッセージが処理される) に設定され
      ます。

      レベルの一覧については ロギングレベル を参照してください。

      バージョン 3.2 で変更: *level* パラメータは、 "INFO" のような整
      数定数の代わりに 'INFO' のようなレベルの文字列表現も受け付けるよ
      うになりました。

   setFormatter(fmt)

      Sets the formatter for this handler to *fmt*. The *fmt* argument
      must be a "Formatter" instance or "None".

   addFilter(filter)

      指定されたフィルタ *filter* をこのハンドラに追加します。

   removeFilter(filter)

      指定されたフィルタ *filter* をこのハンドラから除去します。

   filter(record)

      レコードに対してこのハンドラのフィルタを適用し、レコードが処理さ
      れるべき場合に "True" を返します。フィルタのいずれかの値が偽を返
      すまで、それらは順番に試されていきます。いずれも偽を返さなければ
      、レコードは発行されることになります。ひとつでも偽を返せば、ハン
      ドラはレコードを発行しません。

   flush()

      すべてのログ出力がフラッシュされるようにします。このクラスのバー
      ジョンではなにも行わず、サブクラスで実装するためのものです。

   close()

      Tidy up any resources used by the handler. This version does no
      output but removes the handler from an internal map of handlers,
      which is used for handler lookup by name.

      Subclasses should ensure that this gets called from overridden
      "close()" methods.

   handle(record)

      ハンドラに追加されたフィルタの条件に応じて、指定されたログレコー
      ドを出力します。このメソッドは I/O スレッドロックの獲得/解放を伴
      う実際のログ出力をラップします。

   handleError(record)

      このメソッドは、 "emit()" の呼び出し中に例外に遭遇した際にハンド
      ラから呼び出されることを想定しています。モジュールレベルの属性
      "raiseExceptions" が "False" の場合、例外は静かに無視されます。
      これは、ほとんどの場合でロギングシステムに期待される挙動です -
      なぜなら、ほとんどのユーザーはロギングシステムの中で起こったエラ
      ーなどに興味はなく、アプリケーションエラーの方により関心があるか
      らです。しかし、必要ならばこの挙動を自作のハンドラで置き換えるこ
      とができます。引数に指定されたレコードは例外発生時に処理されるも
      のです。 ("raiseExceptions" のデフォルト値は、開発中にはその方が
      便利なので、 "True" です)。

   format(record)

      レコードに対する書式化を行います - フォーマッタが設定されていれ
      ば、それを使います。そうでない場合、モジュールにデフォルト指定さ
      れたフォーマッタを使います。

   emit(record)

      指定されたログ記録レコードを実際にログ記録する際のすべての処理を
      行います。このメソッドはサブクラスで実装されることを意図しており
      、そのためこのクラスのバージョンは "NotImplementedError" を送出
      します。

      警告:

        このメソッドはハンドラレベルのロックを取得した後で呼び出されま
        す。また、ロックはこのメソッドがリターンした後で解放されます。
        このメソッドをオーバーライドする場合、ロックを取得する可能性の
        ある logging API の他の関数やメソッドの呼び出しに注意してくだ
        さい。そのような実装はデッドロックを引き起こす可能性があります
        。特に以下の点に注意してください:

        * ロギングを構成するための API はモジュールレベルのロックを取
          得し、その後ハンドラを構成する際に個々のハンドラに対してハン
          ドラレベルのロックを取得します。

        * 多くのロギング API はモジュールレベルのロックを取得します。
          そのような API がこのメソッドから呼ばれた場合、他のスレッド
          からロギングを構成するための API 呼び出しが行われたときにデ
          ッドロックに陥る可能性があります。これは他のスレッドがハンド
          ラレベルのロックを取得する *前に* モジュールレベルのロックを
          取得しようとする一方で、 (このメソッドはハンドラレベルのロッ
          クが既に取得された状態で呼び出されているため) このメソッドを
          呼び出したスレッドはハンドラレベルのロックを取得した *後で*
          モジュールレベルのロックを取得しようとするためです。

標準として含まれているハンドラについては、 "logging.handlers" を参照し
てください。


フォーマッタオブジェクト
========================

class logging.Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)

   "LogRecord" を、人間または外部のシステムが解釈可能な出力文字列に変
   換する責任を持ちます。

   パラメータ:
      * **fmt** (*str*) -- *style* で指定された書式にもとづく、出力ロ
        グ全体に対する書式文字列です。マッピングのキーは "LogRecord"
        オブジェクトの LogRecord 属性 から取り出されます。特に指定がな
        い場合は、ログメッセージをあらわす "'%(message)s'" が使われま
        す。

      * **datefmt** (*str*) -- A format string for the date/time
        portion of the logged output. If not specified, the default
        described in "formatTime()" is used.

      * **style** (*str*) -- "'%'",  または "'$'" のいずれかで、書式文
        字列がログデータとどのようにマージされるかを決めます: printf
        形式の文字列書式化 ("%"), "str.format()" ("{") または
        "string.Template" () のいずれかを使います。この引数は *fmt* だ
        けに適用されます (たとえば "'%(message)s'" に対して
        "'{message}'") が、ロギングメソッドに渡された実際のログメッセ
        ージには適用されません。いっぽう、 "'{'" や "$" を使ってログメ
        ッセージをフォーマットする 他の方法 も存在します。

      * **validate** (*bool*) -- "True" が指定されると (デフォルト) 、
        *fmt* と *style* が不正な場合や、それらが不適切な組み合わせだ
        った場合に "ValueError" 例外を送出します; たとえば
        "logging.Formatter('%(asctime)s - %(message)s', style='{')" は
        例外となります。

      * **defaults** (*dict**[**str**, **Any**]*) -- カスタムフィール
        ドに使用されるデフォルト値を指定する辞書です。例えば
        "logging.Formatter('%(ip)s %(message)s', defaults={"ip":
        None})" のように使います。

   バージョン 3.2 で変更: *style* パラメータが追加されました。

   バージョン 3.8 で変更: *validate* パラメータが追加されました。

   バージョン 3.10 で変更: *defaults* パラメータが追加されました。

   format(record)

      レコードの属性辞書が、文字列を書式化する演算で被演算子として使わ
      れます。書式化された結果の文字列を返します。辞書を書式化する前に
      、二つの準備段階を経ます。レコードの *message* 属性が *msg* %
      *args* を使って処理されます。書式化された文字列が "'(asctime)'"
      を含むなら、 "formatTime()" が呼び出され、イベントの発生時刻を書
      式化します。例外情報が存在する場合、 "formatException()" を使っ
      て書式化され、メッセージに追加されます。ここで注意していただきた
      いのは、書式化された例外情報は *exc_text* にキャッシュされるとい
      う点です。これが有用なのは例外情報がピックル化されて回線上を送る
      ことができるからですが、しかし二つ以上の "Formatter" サブクラス
      で例外情報の書式化をカスタマイズしている場合には注意が必要になり
      ます。この場合、フォーマッタが書式化を終えるごとにキャッシュをク
      リアして（ *ext_text* 属性に "None" を設定して）、次のフォーマッ
      タがキャッシュされた値を使わずに新鮮な状態で再計算するようにしな
      ければならないことになります。

      スタック情報が利用可能な場合、(必要ならば "formatStack()" を使っ
      て整形した上で) スタック情報が例外情報の後に追加されます。

   formatTime(record, datefmt=None)

      このメソッドは、フォーマッタが書式化された時間を利用したい際に、
      "format()" から呼び出されます。 このメソッドは特定の要求を提供す
      るためにフォーマッタで上書きすることができますが、基本的な振る舞
      いは以下のようになります: *datefmt* (文字列) が指定された場合、
      レコードが生成された時刻を書式化するために "time.strftime()" で
      使われます。 そうでない場合、 '%Y-%m-%d %H:%M:%S,uuu' というフォ
      ーマットが使われます。 uuu 部分はミリ秒値で、それ以外の文字は
      "time.strftime()" ドキュメントに従います。 このフォーマットの時
      刻の例は "2003-01-23 00:29:50,411" です。 結果の文字列が返されま
      す。

      この関数は、ユーザが設定できる関数を使って、生成時刻をタプルに変
      換します。デフォルトでは、 "time.localtime()" が使われます。特定
      のフォーマッタインスタンスに対してこれを変更するには、
      "converter" 属性を "time.localtime()" や "time.gmtime()" と同じ
      署名をもつ関数に設定してください。すべてのフォーマッタインスタン
      スに対してこれを変更するには、例えば全てのロギング時刻を GMT で
      表示するには、 "Formatter" クラスの "converter" 属性を設定してく
      ださい。

      バージョン 3.3 で変更: 以前は、デフォルトのフォーマットがこの例
      のようにハードコーディングされていました: "2010-09-06
      22:38:15,292" ここで、コンマの前の部分は strptime フォーマット文
      字列 ("'%Y-%m-%d %H:%M:%S'") によって扱われる部分で、コンマの後
      の部分はミリ秒値です。strptime にミリ秒のフォーマットプレースホ
      ルダーがないので、ミリ秒値は別のフォーマット文字列 "'%s,%03d'"
      を使用して追加されます。そして、これらのフォーマット文字列は両方
      ともこのメソッドでハードコーディングされていました。変更後は、こ
      れらの文字列はクラスレベル属性として定義され、必要ならインスタン
      スレベルでオーバーライドすることができます。属性の名前は
      "default_time_format" (strptime 書式文字列用) と
      "default_msec_format" (ミリ秒値の追加用) です。

      バージョン 3.9 で変更: "default_msec_format" 引数が "None" であ
      ることを許容します。

   formatException(exc_info)

      指定された例外情報 ("sys.exc_info()" が返すような標準例外のタプ
      ル) を文字列として書式化します。デフォルトの実装は単に
      "traceback.print_exception()" を使います。結果の文字列が返されま
      す。

   formatStack(stack_info)

      指定されたスタック情報を文字列としてフォーマットします
      ("traceback.print_stack()" によって返される文字列ですが、最後の
      改行が取り除かれています)。このデフォルト実装は、単に入力値をそ
      のまま返します。

class logging.BufferingFormatter(linefmt=None)

   複数のレコードをまとめてフォーマットしたい場合のクラス定義に適した
   基底クラスです。各行 (単一のレコードに相当します) をフォーマットす
   るために使う "Formatter" インスタンスを渡すことができます。特に指定
   がない場合はデフォルトのフォーマッタ (イベントのメッセージだけを出
   力するフォーマッタ) が使われます。

   formatHeader(records)

      *複数のレコード* のリストに対するヘッダを返します。基底クラスの
      実装は単に空の文字列を返すだけです。レコード数やタイトルを表示し
      たり、あるいはセパレータ行したいなど、ヘッダに対して特別な振る舞
      いが必要な場合はこのメソッドをオーバーライドする必要があります。

   formatFooter(records)

      *複数のレコード* のリストに対するフッタを返します。基底クラスの
      実装は単に空の文字列を返すだけです。レコード数やセパレータ行の表
      示など、フッタに対して特別な振る舞いが必要な場合はこのメソッドを
      オーバーライドする必要があります。

   format(records)

      *複数のレコード* のリストに対するフォーマット済みテキストを返し
      ます。基底クラスの実装は、レコードがなければ空の文字列を返し、レ
      コードがある場合はヘッダ、単一のレコードをフォーマットするための
      ラインフォーマッタで各レコードをフォーマットした文字列、そしてフ
      ッタを全て連結したものを返します。


フィルタオブジェクト
====================

"フィルタ (Filter)" は、"ハンドラ" や "ロガー" によって使われ、レベル
によって提供されるのよりも洗練されたフィルタリングを実現します。基底の
フィルタクラスは、ロガー階層構造内の特定地点の配下にあるイベントだけを
許可します。例えば、'A.B' で初期化されたフィルタは、ロガー 'A.B',
'A.B.C', 'A.B.C.D', 'A.B.D' 等によって記録されたイベントは許可しますが
、'A.BB', 'B.A.B' などは許可しません。空の文字列で初期化された場合、す
べてのイベントを通過させます。

class logging.Filter(name='')

   "Filter" クラスのインスタンスを返します。 *name* が指定されていれば
   、 *name* はロガーの名前を表します。指定されたロガーとその子ロガー
   のイベントがフィルタを通過できるようになります。 *name* が指定され
   なければ、すべてのイベントを通過させます。

   filter(record)

      指定されたログレコードは記録されるでしょうか？答えが「いいえ」な
      ら false を、「はい」なら true を返します。フィルタは受け取った
      ログレコードそのものを編集したり、その後のイベント処理において元
      のログレコードに取って代わる、まったく異なるログレコードインスタ
      ンスを返す可能性があります。

ハンドラに対するフィルタはハンドラがイベントを発行する前に試され、一方
ではロガーに対するフィルタは、イベントが("debug()", "info()" などによ
って)ロギングされる際には、ハンドラにイベントが送信される前にはいつで
も試されることに注意してください。そのフィルタがそれら子孫ロガーにも適
用されていない限り、子孫ロガーによって生成されたイベントはロガーのフィ
ルタ設定によってフィルタされることはありません。

実際には、"Filter" をサブクラス化する必要はありません。同じ意味の
"filter" メソッドを持つ、すべてのインスタンスを通せます。

バージョン 3.2 で変更: 特殊な "Filter" クラスを作ったり、 "filter" メ
ソッドを持つ他のクラスを使う必要はありません: 関数 (あるいは他の
callable) をフィルタとして使用することができます。フィルタロジックは、
フィルタオブジェクトが "filter" 属性を持っているかどうかチェックします
: もし "filter" 属性を持っていたら、それは "Filter" であると仮定され、
その "filter()" メソッドが呼び出されます。そうでなければ、それは
callable であると仮定され、レコードを単一のパラメータとして呼び出され
ます。返される値は "filter()" によって返されるものと一致すべきです。

バージョン 3.12 で変更: 受け取ったログレコード自体を編集する代わりに、
元のログレコードに取って代わる別の "LogRecord" インスタンスを返すこと
ができるようになりました。これにより、 "Handler" にアタッチされたフィ
ルタが、他のハンドラへの副作用を伴うことなく、発行前にログレコードを編
集することが可能になります。

フィルタは本来、レコードをレベルよりも洗練された基準に基づいてフィルタ
するために使われますが、それが取り付けられたハンドラやロガーによって処
理されるレコードをすべて監視します。これは、特定のロガーやハンドラに処
理されたレコードの数を数えたり、処理されている "LogRecord" の属性を追
加、変更、削除したりするときに便利です。もちろん、LogRecord を変更する
には注意が必要ですが、これにより、ログにコンテキスト情報を注入できます
(Filter を使ったコンテキスト情報の伝達 を参照してください)。


LogRecord オブジェクト
======================

"LogRecord" インスタンスは、何かをログ記録するたびに "Logger" によって
生成されます。また、 "makeLogRecord()" を通して (例えば、ワイヤを通し
て受け取られた pickle 化されたイベントから) 手動で生成することも出来ま
す。

class logging.LogRecord(name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None)

   ロギングされているイベントに適切なすべての情報を含みます。

   もっとも重要な情報は *msg* と *args* に渡され、 "msg % args" で結合
   されてレコードの "message" 属性を生成します。

   パラメータ:
      * **name** (*str*) -- この "LogRecord" であらわされるイベントを
        記録したロガーの名前です。 "LogRecord" が持つロガーの名前は、
        たとえ異なる (祖先の) ロガーに接続されたハンドラから出力された
        としても、常に同じ値を持つことに注意してください。

      * **level** (*int*) -- 記録されたイベントの 数値であらわしたロギ
        ングレベル  ("10" が "DEBUG", "20" が "INFO" など) です。この
        パラメータは LogRecord の *2つの* 属性に変換されることに注意し
        てください: 数値は "levelno" に、また対応するログレベルの名前
        は "levelname" に保持されます。

      * **pathname** (*str*) -- ロギングの呼び出しが行われたソースファ
        イルへの完全なパス名をあらわす文字列です。

      * **lineno** (*int*) -- ロギングの呼び出しが発せられたソース行番
        号。

      * **msg** (*Any*) -- イベントの説明メッセージ。様々なデータのプ
        レースホルダを含んだ %フォーマット文字列か、任意のオブジェクト
        (任意のオブジェクトをメッセージに使用する を参照)。

      * **args** (*tuple** | **dict**[**str**, **Any**]*) -- *msg* 引
        数と組み合わせてイベント記述を得るための変数データです。

      * **exc_info** (*tuple**[**type**[**BaseException**]**,
        **BaseException**, **types.TracebackType**] **| **None*) --
        "sys.exc_info()" によって返される現在の例外情報を含む例外タプ
        ルです。例外情報がない場合は "None" です。

      * **func** (*str** | **None*) -- ロギングの呼び出しを行った関数
        またはメソッドの名前です。

      * **sinfo** (*str** | **None*) -- 現在のスレッドのスタックベース
        からログ呼び出しまでの間のスタック情報を表わすテキスト文字列。

   getMessage()

      ユーザが提供した引数をメッセージに交ぜた後、この "LogRecord" イ
      ンスタンスへのメッセージを返します。ユーザがロギングの呼び出しに
      与えた引数が文字列でなければ、その引数に "str()" が呼ばれ、文字
      列に変換されます。これにより、 "__str__" メソッドが実際のフォー
      マット文字列を返せるようなユーザ定義のクラスをメッセージとして使
      えます。

   バージョン 3.2 で変更: "LogRecord" の生成は、レコードを生成するため
   に使用されるファクトリを提供することにより、さらに設定可能になりま
   した。ファクトリは "getLogRecordFactory()" と
   "setLogRecordFactory()" を使用して設定することができます (ファクト
   リのシグネチャに関しては "setLogRecordFactory()" を参照)。

   この機能を使うと "LogRecord" の生成時に独自の値を注入することができ
   ます。次のパターンが使えます:

      old_factory = logging.getLogRecordFactory()

      def record_factory(*args, **kwargs):
          record = old_factory(*args, **kwargs)
          record.custom_attribute = 0xdecafbad
          return record

      logging.setLogRecordFactory(record_factory)

   このパターンでは複数のファクトリをつなぐこともできます。それらが互
   いの属性を上書きしたりせず、また上にリストされた標準属性を意図せず
   上書きしたりしない限り、驚くようなことは何も起こりません (there
   should be no surprises)。


LogRecord 属性
==============

LogRecord には幾つかの属性があり、そのほとんどはコンストラクタの引数か
ら得られます。(なお、LogRecord コンストラクタの引数と LogRecord 属性が
常に厳密に対応するわけではありません。) これらの属性は、レコードからの
データをフォーマット文字列に統合するのに使えます。以下のテーブルに、属
性名、意味、そして % 形式フォーマット文字列における対応するプレースホ
ルダを (アルファベット順に) 列挙します。

{}-フォーマット ("str.format()") を使用していれば、書式文字列の中でプ
レースホールダーとして "{attrname}" を使うことができます。 $-フォーマ
ット ("string.Template") を使用している場合は、 "${attrname}" 形式にし
てください。もちろん、両方の場合で "attrname" は使用したい実際の属性名
に置き換えてください。

{}-フォーマットの場合には、属性名の後にフォーマットフラグを指定するこ
とができます。属性名とフォーマットフラグの間はコロンで分割します。例:
プレースホールダー "{msecs:03.0f}" は、ミリセカンド値 "4" を "004" と
してフォーマットします。利用可能なオプション上の全詳細に関しては
"str.format()" ドキュメンテーションを参照してください。

+------------------+---------------------------+-------------------------------------------------+
| 属性名           | フォーマット              | 説明                                            |
|==================|===========================|=================================================|
| "args"           | このフォーマットを自分で  | "msg" に組み合わせて "message" を生成するための |
|                  | 使う必要はないでしょう。  | 引数のタプル、または、 マージに用いられる辞書(  |
|                  |                           | 引数が一つしかなく、かつそれが辞書の場合)。     |
+------------------+---------------------------+-------------------------------------------------+
| asctime          | "%(asctime)s"             | "LogRecord" が生成された時刻を人間が読める書式  |
|                  |                           | で表したもの。デフォルト では "2003-07-08       |
|                  |                           | 16:49:45,896" 形式 (コンマ以降の数字は時刻のミ  |
|                  |                           | リ秒部 分) です。                               |
+------------------+---------------------------+-------------------------------------------------+
| created          | "%(created)f"             | "LogRecord" が生成された時刻です                |
|                  |                           | ("time.time_ns()" / 1e9 で返される形 式で)。    |
+------------------+---------------------------+-------------------------------------------------+
| exc_info         | このフォーマットを自分で  | ("sys.exc_info" 風の) 例外タプルか、例外が起こ  |
|                  | 使う必要はないでしょう。  | っていない場合は "None" 。                      |
+------------------+---------------------------+-------------------------------------------------+
| exc_text         | このフォーマットを自分で  | Exception information formatted as a string.    |
|                  | 使う必要はないでしょう。  | This is set when "Formatter.format()" is        |
|                  |                           | invoked, or "None" if no exception has          |
|                  |                           | occurred.                                       |
+------------------+---------------------------+-------------------------------------------------+
| ファイル名       | "%(filename)s"            | "pathname" のファイル名部分。                   |
+------------------+---------------------------+-------------------------------------------------+
| funcName         | "%(funcName)s"            | ロギングの呼び出しを含む関数の名前。            |
+------------------+---------------------------+-------------------------------------------------+
| levelname        | "%(levelname)s"           | メッセージのための文字のロギングレベル          |
|                  |                           | ("'DEBUG'", "'INFO'", "'WARNING'", "'ERROR'",   |
|                  |                           | "'CRITICAL'")。                                 |
+------------------+---------------------------+-------------------------------------------------+
| levelno          | "%(levelno)s"             | メッセージのための数値のロギングレベル          |
|                  |                           | ("DEBUG", "INFO", "WARNING", "ERROR",           |
|                  |                           | "CRITICAL")。                                   |
+------------------+---------------------------+-------------------------------------------------+
| lineno           | "%(lineno)d"              | ロギングの呼び出しが発せられたソース行番号 (利  |
|                  |                           | 用できる場合のみ)。                             |
+------------------+---------------------------+-------------------------------------------------+
| message          | "%(message)s"             | "msg % args" として求められた、ログメッセージ。 |
|                  |                           | "Formatter.format()" が呼び出されたときに設定さ |
|                  |                           | れます。                                        |
+------------------+---------------------------+-------------------------------------------------+
| module           | "%(module)s"              | モジュール ("filename" の名前部分)。            |
+------------------+---------------------------+-------------------------------------------------+
| msecs            | "%(msecs)d"               | "LogRecord" が生成された時刻のミリ秒部分。      |
+------------------+---------------------------+-------------------------------------------------+
| msg              | このフォーマットを自分で  | 元のロギングの呼び出しで渡されたフォーマット文  |
|                  | 使う必要はないでしょう。  | 字列。 "args" と合わせて 、 "message" 、または  |
|                  |                           | 任意のオブジェクトを生成します (任意のオブジェ  |
|                  |                           | ク トをメッセージに使用する 参照)。             |
+------------------+---------------------------+-------------------------------------------------+
| name             | "%(name)s"                | ロギングに使われたロガーの名前。                |
+------------------+---------------------------+-------------------------------------------------+
| pathname         | "%(pathname)s"            | ロギングの呼び出しが発せられたファイルの完全な  |
|                  |                           | パス名 (利用できる場合の み)。                  |
+------------------+---------------------------+-------------------------------------------------+
| process          | "%(process)d"             | プロセス ID (利用可能な場合のみ)。              |
+------------------+---------------------------+-------------------------------------------------+
| processName      | "%(processName)s"         | プロセス名 (利用可能な場合のみ)。               |
+------------------+---------------------------+-------------------------------------------------+
| relativeCreated  | "%(relativeCreated)d"     | logging モジュールが読み込まれた時刻に対する、  |
|                  |                           | LogRecord が生成された時 刻を、ミリ秒で表したも |
|                  |                           | の。                                            |
+------------------+---------------------------+-------------------------------------------------+
| stack_info       | このフォーマットを自分で  | 現在のスレッドでのスタックの底からこのレコード  |
|                  | 使う必要はないでしょう。  | の生成に帰着したログ呼び 出しまでのスタックフレ |
|                  |                           | ーム情報 (利用可能な場合)。                     |
+------------------+---------------------------+-------------------------------------------------+
| thread           | "%(thread)d"              | スレッド ID (利用可能な場合のみ)。              |
+------------------+---------------------------+-------------------------------------------------+
| threadName       | "%(threadName)s"          | スレッド名 (利用可能な場合のみ)。               |
+------------------+---------------------------+-------------------------------------------------+
| taskName         | "%(taskName)s"            | "asyncio.Task" 名 (利用可能な場合のみ)。        |
+------------------+---------------------------+-------------------------------------------------+

バージョン 3.1 で変更: *processName* が追加されました。

バージョン 3.12 で変更: *taskName* が追加されました。


LoggerAdapter オブジェクト
==========================

"LoggerAdapter" インスタンスは文脈情報をログ記録呼び出しに渡すのを簡単
にするために使われます。使い方の例は コンテキスト情報をログ記録出力に
付加する を参照してください。

class logging.LoggerAdapter(logger, extra=None, merge_extra=False)

   Returns an instance of "LoggerAdapter" initialized with an
   underlying "Logger" instance, an optional dict-like object
   (*extra*), and an optional boolean (*merge_extra*) indicating
   whether or not the *extra* argument of individual log calls should
   be merged with the "LoggerAdapter" extra. The default behavior is
   to ignore the *extra* argument of individual log calls and only use
   the one of the "LoggerAdapter" instance

   process(msg, kwargs)

      文脈情報を挿入するために、ログ記録呼び出しに渡されたメッセージお
      よび/またはキーワード引数に変更を加えます。ここでの実装は
      *extra* としてコンストラクタに渡されたオブジェクトを取り、
      'extra' キーを使って *kwargs* に加えます。返り値は (*msg*,
      *kwargs*) というタプルで、(変更されているはずの) 渡された引数を
      含みます。

   manager

      背後にある *logger* の "manager" メソッドを代理で呼び出します。

   _log

      背後にある *logger* の "_log()" メソッドを代理で呼び出します。

   "LoggerAdapter" は上記に加え "Logger" のメソッド "debug()",
   "info()", "warning()", "error()", "exception()", "critical()",
   "log()", "isEnabledFor()", "getEffectiveLevel()", "setLevel()",
   "hasHandlers()" をサポートします。これらは "Logger" の対応するメソ
   ッドと同じシグニチャを持つため、2つのインスタンスは区別せずに利用出
   来ます。

   バージョン 3.2 で変更: "isEnabledFor()", "getEffectiveLevel()",
   "setLevel()", "hasHandlers()" が "LoggerAdapter" に追加されました。
   これらメソッドは元のロガーに処理を委譲します。

   バージョン 3.6 で変更: 基底のロガーに移譲し、アダプターをネストでき
   るようにするために "manager" 属性と "_log()" メソッドが追加されまし
   た。

   バージョン 3.10 で変更: *extra* 引数が任意になりました。

   バージョン 3.13 で変更: *merge_extra* 引数が追加されました。


スレッドセーフ性
================

logging モジュールは、クライアントで特殊な作業を必要としない限りスレッ
ドセーフになっています。このスレッドセーフ性はスレッドロックによって達
成されています; モジュールの共有データへのアクセスを直列化するためのロ
ックが一つ存在し、各ハンドラでも背後にある I/O へのアクセスを直列化す
るためにロックを生成します。

"signal" モジュールを使用して非同期シグナルハンドラを実装している場合
、そのようなハンドラからはログ記録を使用できないかもしれません。これは
、 "threading" モジュールにおけるロック実装が常にリエントラントではな
く、そのようなシグナルハンドラから呼び出すことができないからです。


モジュールレベルの関数
======================

上で述べたクラスに加えて、いくつかのモジュールレベルの関数が存在します
。

logging.getLogger(name=None)

   指定された名前のロガーを返します。名前が "None" であれば、ロガーの
   階層構造におけるルートロガーを返します。名前を指定する場合は、典型
   的には *'a'*、 *'a.b'* または *'a.b.c.d'* のようなドット区切りの階
   層的な名前にします。名前の付け方は完全にログ機能を使う開発者次第で
   すが、 ロガーオブジェクト で言及されている通り、特に理由がなければ
   "__name__" を使うことが推奨されます。

   与えられた名前に対して、この関数はどの呼び出しでも同じロガーインス
   タンスを返します。したがって、ロガーインスタンスをアプリケーション
   の各部でやりとりする必要はありません。

logging.getLoggerClass()

   標準の "Logger" クラスか、最後に "setLoggerClass()" に渡したクラス
   を返します。この関数は、新たなクラス定義の中で呼び出して、カスタマ
   イズした "Logger" クラスのインストールが既に他のコードで適用したカ
   スタマイズを取り消さないことを保証するために使われることがあります
   。例えば以下のようにします:

      class MyLogger(logging.getLoggerClass()):
          # ... override behaviour here

logging.getLogRecordFactory()

   "LogRecord" を生成するのに使われる callable を返します。

   Added in version 3.2: この関数は、ログイベントを表現する
   "LogRecord" の構築方法に関して開発者により多くのコントロールを与え
   るため、 "setLogRecordFactory()" とともに提供されました。

   このファクトリがどのように呼ばれるかに関する詳細は
   "setLogRecordFactory()" を参照してください。

logging.debug(msg, *args, **kwargs)

   ルートロガーの "Logger.debug()" メソッドを呼び出す便利関数です。引
   数の取り扱いはあらゆる点で当該メソッドと同じです。

   唯一の違いはルートロガーがハンドラを持たない場合で、この場合はルー
   トロガーの "debug" メソッドを呼び出す前に "basicConfig()" が呼ばれ
   ます。

   非常に短いスクリプトや "logging" の機能についての簡単なデモに対して
   は、 "debug" やその他のモジュールレベル関数は便利でしょう。しかしな
   がら、ほとんどのプログラムはロギングの設定を慎重かつ明示的に制御し
   たいはずです。したがって、このドキュメントの最初に書かれているとお
   り、モジュールレベルのロガーを生成してそのロガーに対する
   "Logger.debug()" メソッド (または他のログレベル固有のメソッド) を呼
   び出す方を好むでしょう。

logging.info(msg, *args, **kwargs)

   ルートロガーに対してログレベル "INFO" でメッセージを記録します。引
   数と振る舞いは、ログレベルを除けば "debug()" と同じです。

logging.warning(msg, *args, **kwargs)

   ルートロガーに対してログレベル "WARNING" でメッセージを記録します。
   引数と振る舞いは、ログレベルを除けば "debug()" と同じです。

   注釈:

     "warning" と機能的に等価な古い関数 "warn" があります。"warn" は廃
     止予定なので使わないでください - 代わりに "warning" を使ってくだ
     さい。

logging.error(msg, *args, **kwargs)

   ルートロガーに対してログレベル "ERROR" でメッセージを記録します。引
   数と振る舞いは、ログレベルを除けば "debug()" と同じです。

logging.critical(msg, *args, **kwargs)

   ルートロガーに対してログレベル "CRITICAL" でメッセージを記録します
   。引数と振る舞いは、ログレベルを除けば "debug()" と同じです。

logging.exception(msg, *args, **kwargs)

   ルートロガーに対してログレベル "ERROR" でメッセージを記録します。引
   数と振る舞いは、ログレベルを除けば "debug()" と同じです。例外情報が
   ログメッセージに追加されます。この関数は例外ハンドラからのみ呼び出
   されるべきです。

logging.log(level, msg, *args, **kwargs)

   ルートロガーに対して *level* で指定したログレベルでメッセージを記録
   します。引数と振る舞いは、ログレベルを除けば "debug()" と同じです。

logging.disable(level=CRITICAL)

   全てのロガーのレベル *level* を上書きし、これはロガー自身の出力レベ
   ルよりも優先されます。アプリケーション全体を横断するログ出力を一時
   的に調整する必要が生じたら、この関数は便利でしょう。これの効果は重
   大度 *level* 以下の全てのロギング呼び出しを無効にすることですので、
   INFO で呼び出しをすれば、INFO と DEBUG イベントが捨てられる一方で、
   重大度 WARNING 以上のものは、ロガーの有効レベルに基いて処理されます
   。 "logging.disable(logging.NOTSET)" が呼び出されると、この上書きレ
   ベルは削除され、ログ出力は再び個々のロガーの有効レベルに依存するよ
   うになります。

   "CRITICAL" より高い独自のログレベル (これは推奨されません) を定義し
   た場合は、 *level* 引数のデフォルト値を当てにできなくなり、適切な値
   を明示的に与える必要があります。

   バージョン 3.7 で変更: *level* 引数のデフォルトが "CRITICAL" レベル
   になりました。この変更についてのより詳しいことは bpo-28524 を参照し
   てください。

logging.addLevelName(level, levelName)

   内部的な辞書の中でレベル *level* をテキスト *levelName* に関連付け
   ます。これは例えば "Formatter" でメッセージを書式化する際のように、
   数字のレベルをテキスト表現に対応付ける際に用いられます。この関数は
   自作のレベルを定義するために使うこともできます。使われるレベルに対
   する唯一の制限は、レベルは正の整数でなくてはならず、メッセージの深
   刻度が上がるに従ってレベルの数も上がらなくてはならないということで
   す。

   注釈:

     独自のレベルを定義したい場合、 カスタムレベル のセクションを参照
     してください。

logging.getLevelNamesMapping()

   ログレベルの名前と対応するログレベルのマッピングを返します。例えば
   、文字列 "CRITICAL" は "CRITICAL" にマップされます。この関数が返す
   マッピングオブジェクトは、関数呼び出しのたびに内部のマッピングをコ
   ピーしたものです。

   Added in version 3.11.

logging.getLevelName(level)

   テキストまたは数値表現でログレベル *level* を返してください。

   *level* が定義済みのレベル "CRITICAL", "ERROR", "WARNING", "INFO",
   "DEBUG" のいずれかである場合、対応する文字列が返されます。
   "addLevelName()" を使ってレベルに名前を関連付けていた場合、 *level*
   に関連付けられた名前が返されます。定義済みのレベルに対応する数値を
   指定した場合、レベルに対応した文字列表現を返します。

   *level* パラメータは、 "INFO" のような整数定数の代わりに 'INFO' の
   ようなレベルの文字列表現も受け付けます。この場合、この関数は関連す
   るレベルの数値表現を返します。

   もし渡された数値や文字列がマッチしなければ、 'Level %s' % level が
   返されます。

   注釈:

     レベルは内部的には整数です(これはロギングのロジックが大小比較をす
     る必要があるからです)。この関数は、数値のレベルを、書式記述子
     "%(levelname)s" (LogRecord 属性 参照)によって書式化されるログ出力
     の表示用レベル名に変換するなどの用途に使用されます。

   バージョン 3.4 で変更: In Python versions earlier than 3.4, this
   function could also be passed a text level, and would return the
   corresponding numeric value of the level. This undocumented
   behaviour was considered a mistake, and was removed in Python 3.4,
   but reinstated in 3.4.2 in order to retain backward compatibility.

logging.getHandlerByName(name)

   *name* に指定した名前のハンドラを返します。指定した名前のハンドラが
   ない場合は "None" を返します。

   Added in version 3.12.

logging.getHandlerNames()

   全ての既知のハンドラ名の、イミュータブルな集合を返します。

   Added in version 3.12.

logging.makeLogRecord(attrdict)

   属性が *attrdict* で定義された、新しい "LogRecord" インスタンスを生
   成して返します。この関数は、 pickle された "LogRecord" 属性の辞書を
   ソケットを介して送信し、受信端で "LogRecord" インスタンスとして再構
   成する場合に便利です。

logging.basicConfig(**kwargs)

   Does basic configuration for the logging system by either creating
   a "StreamHandler" with a default "Formatter" or using the  given
   *formatter* instance, and adding it to the root logger. The
   functions "debug()", "info()", "warning()", "error()" and
   "critical()" will call "basicConfig()" automatically if no handlers
   are defined for the root logger.

   この関数は *force* キーワード引数に "True" が設定されない限り、ルー
   トロガーに設定されたハンドラがあれば何もしません。

   注釈:

     この関数は、他のスレッドが開始される前にメインスレッドから呼び出
     されるべきです。Python の 2.7.1 や 3.2 以前のバージョンでは、この
     関数が複数のスレッドから呼ばれると(珍しい状況下とはいえ)ハンドラ
     がルートロガーに複数回加えられることがあり、ログ内のメッセージが
     重複するという予期しない結果をもたらすことがあります。

   以下のキーワード引数がサポートされます。

   +----------------+-----------------------------------------------+
   | フォーマット   | 説明                                          |
   |================|===============================================|
   | *filename*     | "StreamHandler" ではなく指定された名前で      |
   |                | "FileHandler" が作られま す。                 |
   +----------------+-----------------------------------------------+
   | *filemode*     | *filename* が指定された場合、この モード でフ |
   |                | ァイルが開かれます。 デフォルトは  "'a'" です |
   |                | 。                                            |
   +----------------+-----------------------------------------------+
   | *format*       | ハンドラーで指定されたフォーマット文字列を使  |
   |                | います。デフォルトは "levelname", "name",     |
   |                | "message" 属性をコロン区切りにしたものです。  |
   +----------------+-----------------------------------------------+
   | *datefmt*      | 指定された日時の書式で "time.strftime()" が受 |
   |                | け付けるものを使います 。                     |
   +----------------+-----------------------------------------------+
   | *style*        | *format* が指定された場合、書式文字列にこのス |
   |                | タイルを仕様します。 "'%'", "'{'", "'$'" のう |
   |                | ち1つで、それぞれ printf-style,               |
   |                | "str.format()", "string.Template" に対応しま  |
   |                | す。 デフォルトは "'%'" です。                |
   +----------------+-----------------------------------------------+
   | *level*        | ルートロガーのレベルを指定された レベル に設  |
   |                | 定します。                                    |
   +----------------+-----------------------------------------------+
   | *stream*       | 指定されたストリームを "StreamHandler" の初期 |
   |                | 化に使います。 この引 数は *filename* と同時  |
   |                | には使えないことに注意してください。 両方が指 |
   |                | 定されたときには "ValueError" が送出されます  |
   |                | 。                                            |
   +----------------+-----------------------------------------------+
   | *handlers*     | もし指定されれば、 これは root ロガーに追加さ |
   |                | れる既に作られたハンド ラのイテラブルになりま |
   |                | す。まだフォーマッタがセットされていないすべ  |
   |                | てのハンドラは、この関数で作られたデフォルト  |
   |                | フォーマッタが割り当て られることになります。 |
   |                | この引数は *filename* や *stream* と互換性が  |
   |                | ないことに注意してください。両方が存在する場  |
   |                | 合 "ValueError" が上げ られます。             |
   +----------------+-----------------------------------------------+
   | *force*        | このキーワード引数が真に設定されている場合、  |
   |                | ルートのロガーに取り付 けられたハンドラは全て |
   |                | 取り除かれ、他の引数によって指定された設定が  |
   |                | 有効になる前に閉じられます。                  |
   +----------------+-----------------------------------------------+
   | *encoding*     | もしこのキーワード引数が *filename* とともに  |
   |                | 指定された場合、 "FileHandler" が作成されると |
   |                | きにこの値が利用され、出力ファイルを開 く時に |
   |                | 使用されます。                                |
   +----------------+-----------------------------------------------+
   | *errors*       | もしこのキーワード引数が *filename* とともに  |
   |                | 指定された場合、 "FileHandler" が作成されると |
   |                | きのこの値が使用され、出力ファイルを開 く時に |
   |                | 使われます。もし指定されなかった場合、        |
   |                | 'backslashreplace' が 使用されます。もし      |
   |                | "None" が指定されると "open()" のように渡され |
   |                | 、 'errors' を渡したのと同じように扱われます  |
   |                | 。                                            |
   +----------------+-----------------------------------------------+
   | *formatter*    | If specified, set this formatter instance     |
   |                | (see フォーマッタオブジェ クト) for all       |
   |                | involved handlers. If not specified, the      |
   |                | default is to create and use an instance of   |
   |                | "logging.Formatter" based on arguments        |
   |                | *format*, *datefmt* and *style*. When         |
   |                | *formatter* is specified together with any of |
   |                | the three arguments *format*, *datefmt* and   |
   |                | *style*, a "ValueError" is raised to signal   |
   |                | that these arguments would lose meaning       |
   |                | otherwise.                                    |
   +----------------+-----------------------------------------------+

   バージョン 3.2 で変更: *style* 引数が追加されました。

   バージョン 3.3 で変更: 互換性のない引数が指定された状況 (例えば
   *handlers* が *stream* や *filename* と一緒に指定されたり、*stream*
   が *filename* と一緒に指定された場合) を捕捉するために、追加のチェ
   ックが加えられました。

   バージョン 3.8 で変更: *force* 引数が追加されました。

   バージョン 3.9 で変更: *encoding* と *errors* 引数が追加されました
   。

   バージョン 3.15 で変更: The *formatter* argument was added.

logging.shutdown()

   ロギングシステムに対して、バッファのフラッシュを行い、すべてのハン
   ドラを閉じることで順次シャットダウンを行うように告知します。この関
   数はアプリケーションの終了時に呼ばれるべきであり、また呼び出し以降
   はそれ以上ロギングシステムを使ってはなりません。

   loggingモジュールがインポートされると、この関数が終了ハンドラーとし
   て登録されます（ "atexit" 参照）。そのため、通常はこれを手動で行う
   必要はありません。

logging.setLoggerClass(klass)

   ロギングシステムに対して、ロガーをインスタンス化する際にクラス
   *klass* を使うように指示します。 指定するクラスは引数として名前だけ
   をとるようなメソッド "__init__()" を定義していなければならず、
   "__init__()" では "Logger.__init__()" を呼び出さなければなりません
   。 この関数が呼び出されるのはたいてい、独自の振る舞いをするロガーを
   使う必要のあるアプリケーションでロガーがインスタンス化される前です
   。 呼び出された後は、いつでもそのサブクラスを使ってロガーのインスタ
   ンス化をしてはいけません: 引き続き "logging.getLogger()" API を使用
   してロガーを取得してください。

logging.setLogRecordFactory(factory)

   "LogRecord" を生成するのに使われる callable をセットします。

   パラメータ:
      **factory** -- ログレコードを生成するファクトリとして振舞う
      callable。

   Added in version 3.2: この関数は、ログイベントを表現する
   "LogRecord" の構築方法に関して開発者により多くのコントロールを与え
   るため、 "getLogRecordFactory()" とともに提供されました。

   ファクトリは以下のようなシグネチャを持っています:

   "factory(name, level, fn, lno, msg, args, exc_info, func=None,
   sinfo=None, **kwargs)"

      name:
         ロガーの名前。

      level:
         ログレベル (数値)。

      fn:
         ログ呼び出しが行われたファイルのフルパス名。

      lno:
         ログ呼び出しが行われたファイルの行数。

      msg:
         ログメッセージ。

      "args":
         ログメッセージに対する引数。

      exc_info:
         例外タプルまたは "None"。

      func:
         ログ呼び出しを起動した関数またはメソッドの名前。

      sinfo:
         "traceback.print_stack()" で提供されるような、呼び出し階層を
         示すスタックトレースバック。

      "kwargs":
         追加のキーワード引数。


モジュールレベル属性
====================

logging.lastResort

   「最後の手段のハンドラ」が、この属性で利用可能です。これは
   "StreamHandler" が "sys.stderr" に "WARNING" レベルで書き出している
   のがそうですし、ロギングの設定がなにか不在のロギングイベントを扱う
   場合に使われます。最終的な結果は、メッセージを単に "sys.stderr" に
   出力することです。これはかつて「logger XYZ についてのハンドラが見つ
   かりません」と言っていたエラーメッセージを置き換えています。もしも
   何らかの理由でその昔の振る舞いが必要な場合は、 "lastResort" に
   "None" をセットすれば良いです。

   Added in version 3.2.

logging.raiseExceptions

   ログメッセージの処理中に発生した例外を伝播させるかどうかを調べるた
   めに使われます。

   デフォルト: "True".

   "raiseExceptions" が "False" の場合、発生した例外は静かに無視されま
   す。これはほとんどのログシステムにおいて望ましい動作です - ほとんど
   のユーザーはログシステムのエラーには興味がなく、アプリケーションの
   エラーにより強い関心を持つでしょう。


warnings モジュールとの統合
===========================

The "captureWarnings()" function can be used to integrate "logging"
with the "warnings" module.

logging.captureWarnings(capture)

   この関数は、logging による警告の補足を、有効にまたは無効にします。

   *capture* が "True" なら、 "warnings" モジュールに発せられた警告は
   、ロギングシステムにリダイレクトされるようになります。具体的には、
   警告が "warnings.formatwarning()" でフォーマット化され、結果の文字
   列が "'py.warnings'" という名のロガーに、 "WARNING" の重大度でロギ
   ングされるようになります。

   *capture* が "False" なら、警告のロギングシステムに対するリダイレク
   トは止められ、警告は元の (すなわち、"captureWarnings(True)" が呼び
   出される前に有効だった) 送信先にリダイレクトされるようになります。

参考:

  "logging.config" モジュール
     logging モジュールの環境設定 API です。

  "logging.handlers" モジュール
     logging モジュールに含まれる、便利なハンドラです。

  **PEP 282** - ログシステム
     この機能を Python 標準ライブラリに含めることを述べた提案です。

  Python の最初のロギングパッケージ
     This is the original source for the "logging" package.  The
     version of the package available from this site is suitable for
     use with Python 1.5.2, 2.1.x and 2.2.x, which do not include the
     "logging" package in the standard library.
