"logging.config" --- 日志记录配置
*********************************

**源代码：** Lib/logging/config.py


Important
^^^^^^^^^

此页面仅包含参考信息。有关教程，请参阅

* 基础教程

* 进阶教程

* 日志操作手册

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

这一节描述了用于配置 logging 模块的 API。


配置函数
========

下列函数可配置 logging 模块。 它们位于 "logging.config" 模块中。 它们
的使用是可选的 --- 要配置 logging 模块你可以使用这些函数，也可以通过调
用主 API (在 "logging" 本身定义) 并定义在 "logging" 或
"logging.handlers" 中声明的处理程序。

logging.config.dictConfig(config)

      从一个字典获取日志记录配置。 字典的内容描述见下文的 配置字典架构
      。

      如果在配置期间遇到错误，此函数将引发 "ValueError", "TypeError",
      "AttributeError" 或 "ImportError" 并附带适当的描述性消息。 下面
      是将会引发错误的（可能不完整的）条件列表:

      * "level" 不是字符串或者不是对应于实际日志记录级别的字符串。

      * "propagate" 值不是布尔类型。

      * id 没有对应的目标。

      * 在增量调用期间发现不存在的处理程序 id。

      * 无效的日志记录器名称。

      * 无法解析为内部或外部对象。

      解析由 "DictConfigurator" 类执行，该类的构造器可传入用于配置的字
      典，并且具有 "configure()" 方法。 "logging.config" 模块具有可调
      用属性 "dictConfigClass"，其初始值设为 "DictConfigurator"。 你可
      以使用你自己的适当实现来替换 "dictConfigClass" 的值。

      "dictConfig()" 会调用 "dictConfigClass" 并传入指定的字典，然后在
      所返回的对象上调用 "configure()" 方法以使配置生效:

         def dictConfig(config):
             dictConfigClass(config).configure()

      例如，"DictConfigurator" 的子类可以在它自己的 "__init__()" 中调
      用 "DictConfigurator.__init__()"，然后设置可以在后续
      "configure()" 调用中使用的自定义前缀。 "dictConfigClass" 将被绑
      定到这个新的子类，然后就可以与在默认的未定制状态下完全相同的方式
      调用 "dictConfig()"。

   3.2 新版功能.

logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True)

   从一个 "configparser" 格式文件中读取日志记录配置。 文件格式应当与
   Configuration file format 中的描述一致。 此函数可在应用程序中被多次
   调用，以允许最终用户在多个预设配置中进行选择（如果开发者提供了展示
   选项并加载选定配置的机制）。

   参数:
      * **fname** -- 一个文件名，或一个文件类对象，或是一个派生自
        "RawConfigParser" 的实例。 如果传入了一个派生自
        "RawConfigParser" 的实例，它会被原样使用。 否则，将会实例化一
        个 "Configparser"，并且它会从作为 "fname" 传入的对象中读取配置
        。 如果存在 "readline()" 方法，则它会被当作一个文件类对象并使
        用 "read_file()" 来读取；在其它情况下，它会被当作一个文件名并
        传递给 "read()"。

      * **defaults** -- 要传递给 ConfigParser 的默认值可在此参数中指定
        。

      * **disable_existing_loggers** -- 如果指定为 "False"，则当执行此
        调用时已存在的日志记录器会保持启用。 默认值为 "True" 因为这将
        以向下兼容方式启用旧行为。 此行为是禁用任何现有的非根日志记录
        器除非它们或它们的上级在日志记录配置中被显式地命名。

   在 3.4 版更改: 现在接受 "RawConfigParser" 子类的实例作为 "fname" 的
   值。 这有助于:

   * 使用一个配置文件，其中日志记录配置只是全部应用程序配置的一部分。

   * 使用从一个文件读取的配置，它随后会在被传给 "fileConfig" 之前由使
     用配置的应用程序来修改（例如基于命令行参数或运行时环境的其他部分
     ）。

logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None)

   在指定的端口上启动套接字服务器，并监听新的配置。 如果未指定端口，则
   会使用模块默认的 "DEFAULT_LOGGING_CONFIG_PORT"。 日志记录配置将作为
   适合由 "dictConfig()" 或 "fileConfig()" 进行处理的文件来发送。 返回
   一个 "Thread" 实例，你可以在该实例上调用 "start()" 来启动服务器，对
   该服务器你可以在适当的时候执行 "join()"。 要停止该服务器，请调用
   "stopListening()"。

   如果指定 "verify" 参数，则它应当是一个可调用对象，该对象应当验证通
   过套接字接收的字节数据是否有效且应被处理。 这可以通过对通过套接字发
   送的内容进行加密和/或签名来完成，这样 "verify" 可调用对象就能执行签
   名验证和/或解密。 "verify" 可调用对象的调用会附带一个参数 —— 通过套
   接字接收的字节数据 —— 并应当返回要处理的字节数据，或者返回 "None"
   来指明这些字节数据应当被丢弃。 返回的字节数据可以与传入的字节数据相
   同（例如在只执行验证的时候），或者也可以完全不同（例如在可能执行了
   解密的时候）。

   要将配置发送到套接字，请读取配置文件并将其作为字节序列发送到套接字
   ，字节序列要以使用 "struct.pack('>L', n)" 打包为二进制格式的四字节
   长度的字符串打头。

   注解:

     因为配置的各部分是通过 "eval()" 传递的，使用此函数可能让用户面临
     安全风险。 虽然此函数仅绑定到 "localhost" 上的套接字，因此并不接
     受来自远端机器的连接，但在某些场景中不受信任的代码可以在调用
     "listen()" 的进程的账户下运行。 具体来说，如果如果调用 "listen()"
     的进程在用户无法彼此信任的多用户机器上运行，则恶意用户就能简单地
     通过连接到受害者的 "listen()" 套接字并发送运行攻击者想在受害者的
     进程上执行的任何代码的配置的方式，安排运行几乎任意的代码。 如果是
     使用默认端口这会特别容易做到，即便使用了不同端口也不难做到。 要避
     免发生这种情况的风险，请在 "listen()" 中使用 "verify" 参数来防止
     未经认可的配置被应用。

   在 3.4 版更改: 添加了 "verify" 参数。

   注解:

     如果你希望将配置发送给未禁用现有日志记录器的监听器，你将需要使用
     JSON 格式的配置，该格式将使用 "dictConfig()" 进行配置。 此方法允
     许你在你发送的配置中将 "disable_existing_loggers" 指定为 "False"
     。

logging.config.stopListening()

   停止通过对 "listen()" 的调用所创建的监听服务器。 此函数的调用通常会
   先于在 "listen()" 的返回值上调用 "join()"。


配置字典架构
============

描述日志记录配置需要列出要创建的不同对象及它们之间的连接；例如，你可以
创建一个名为 'console' 的处理程序，然后名为 'startup' 的日志记录器将可
以把它的消息发送给 'console' 处理程序。 这些对象并不仅限于 "logging"
模块所提供的对象，因为你还可以编写你自己的格式化或处理程序类。 这些类
的形参可能还需要包括 "sys.stderr" 这样的外部对象。 描述这些对象和连接
的语法会在下面的 对象连接 中定义。


字典架构细节
------------

传给 "dictConfig()" 的字典必须包含以下的键:

* *version* - 应设为代表架构版本的整数值。 目前唯一有效的值是 1，使用
  此键可允许架构在继续演化的同时保持向下兼容性。

所有其他键都是可选项，但如存在它们将根据下面的描述来解读。 在下面提到
'configuring dict' 的所有情况下，都将检查它的特殊键 "'()'" 以确定是否
需要自定义实例化。 如果需要，则会使用下面 用户定义对象 所描述的机制来
创建一个实例；否则，会使用上下文来确定要实例化的对象。

* *formatters* - 对应的值将是一个字典，其中每个键是一个格式器 ID 而每
  个值则是一个描述如何配置相应 "Formatter" 实例的字典。

  将在配置字典中搜索键 "format" 和 "datefmt" (默认值均为 "None") 并且
  这些键会被用于构造 "Formatter" 实例。

  在 3.8 版更改: 一个 "validate" 键 (默认值为 "True") 可被添加到配置字
  典的 "formatters" 部分，这会被用来验证格式的有效性。

* *filters* - 对应的值将是一个字典，其中每个键是一个过滤器 ID 而每个值
  则是一个描述如何配置相应 Filter 实例的字典。

  将在配置字典中搜索键 "name" (默认值为空字符串) 并且该键会被用于构造
  "logging.Filter" 实例。

* *handlers* - 对应的值将是一个字典，其中每个键是一个处理程序 ID 而每
  个值则是一个描述如何配置相应 Handler 实例的字典。

  将在配置字典中搜索下列键:

  * "class" (强制)。 这是处理程序类的完整限定名称。

  * "level" (可选)。 处理程序的级别。

  * "formatter" (可选)。 处理程序所对应格式化器的 ID。

  * "filters" (可选)。 由处理程序所对应过滤器的 ID 组成的列表。

  所有 *其他* 键会被作为关键字参数传递给处理程序类的构造器。 例如，给
  定如下代码段:

     handlers:
       console:
         class : logging.StreamHandler
         formatter: brief
         level   : INFO
         filters: [allow_foo]
         stream  : ext://sys.stdout
       file:
         class : logging.handlers.RotatingFileHandler
         formatter: precise
         filename: logconfig.log
         maxBytes: 1024
         backupCount: 3

  ID 为 "console" 的处理程序会被实例化为 "logging.StreamHandler"，并使
  用 "sys.stdout" 作为下层流。 ID 为 "file" 的处理程序会被实例化为
  "logging.handlers.RotatingFileHandler"，并附带关键字参数
  "filename='logconfig.log', maxBytes=1024, backupCount=3"。

* *loggers* - 对应的值将是一个字典，其中每个键是一个日志记录器名称而每
  个值则是一个描述如何配置相应 Logger 实例的字典。

  将在配置字典中搜索下列键:

  * "level" (可选)。 日志记录器的级别。

  * "propagate" (可选)。 日志记录器的传播设置。

  * "filters" (可选)。 由日志记录器对应过滤器的 ID 组成的列表。

  * "handlers" (可选)。 由日志记录器对应处理程序的 ID 组成的列表。

  指定的日志记录器将根据指定的级别、传播、过滤器和处理程序来配置。

* *root* - 这将成为根日志记录器对应的配置。 配置的处理方式将与所有日志
  记录器一致，除了 "propagate" 设置将不可用之外。

* *incremental* - 配置是否要被解读为在现有配置上新增。 该值默认为
  "False"，这意味着指定的配置将以与当前 "fileConfig()" API 所使用的相
  同语义来替代现有的配置。

  如果指定的值为 "True"，配置会按照 增量配置 部分所描述的方式来处理。

* *disable_existing_loggers* - 是否要禁用任何现有的非根日志记录器。 该
  设置对应于 "fileConfig()" 中的同名形参。 如果省略，则此形参默认为
  "True"。 如果 *incremental* 为 "True" 则该省会被忽略。


增量配置
--------

为增量配置提供完全的灵活性是很困难的。 例如，由于过滤器和格式化器这样
的对象是匿名的，一旦完成配置，在增加配置时就不可能引用这些匿名对象。

此外，一旦完成了配置，在运行时任意改变日志记录器、处理程序、过滤器、格
式化器的对象图就不是很有必要；日志记录器和处理程序的详细程度只需通过设
置级别即可实现控制（对于日志记录器则可设置传播旗标）。 在多线程环境中
以安全的方式任意改变对象图也许会导致问题；虽然并非不可能，但这样做的好
处不足以抵销其所增加的实现复杂度。

这样，当配置字典的 "incremental" 键存在且为 "True" 时，系统将完全忽略
任何 "formatters" 和 "filters" 条目，并仅会处理 "handlers" 条目中的
"level" 设置，以及 "loggers" 和 "root" 条目中的 "level" 和 "propagate"
设置。

使用配置字典中的值可让配置以封存字典对象的形式通过线路传送给套接字监听
器。 这样，长时间运行的应用程序的日志记录的详细程度可随时间改变而无须
停止并重新启动应用程序。


对象连接
--------

该架构描述了一组日志记录对象 —— 日志记录器、处理程序、格式化器、过滤器
—— 它们在对象图中彼此连接。 因此，该架构需要能表示对象之间的连接。 例
如，在配置完成后，一个特定的日志记录器关联到了一个特定的处理程序。 出
于讨论的目的，我们可以说该日志记录器代表两者间连接的源头，而处理程序则
代表对应的目标。 当然在已配置对象中这是由包含对处理程序的引用的日志记
录器来代表的。 在配置字典中，这是通过给每个目标对象一个 ID 来无歧义地
标识它，然后在源头对象中使用该 ID 来实现的。

因此，举例来说，考虑以下 YAML 代码段:

   formatters:
     brief:
       # configuration for formatter with id 'brief' goes here
     precise:
       # configuration for formatter with id 'precise' goes here
   handlers:
     h1: #This is an id
      # configuration of handler with id 'h1' goes here
      formatter: brief
     h2: #This is another id
      # configuration of handler with id 'h2' goes here
      formatter: precise
   loggers:
     foo.bar.baz:
       # other configuration for logger 'foo.bar.baz'
       handlers: [h1, h2]

（注：这里使用 YAML 是因为它的可读性比表示字典的等价 Python 源码形式更
好。）

日志记录器 ID 就是日志记录器的名称，它会在程序中被用来获取对日志记录器
的引用，例如 "foo.bar.baz"。 格式化器和过滤器的 ID 可以是任意字符串值
(例如上面的 "brief", "precise") 并且它们是瞬态的，因为它们仅对处理配置
字典有意义并会被用来确定对象之间的连接，而当配置调用完成时不会在任何地
方保留。

上面的代码片段指明名为 "foo.bar.baz" 的日志记录器应当关联到两个处理程
序，它们的 ID 是 "h1" 和 "h2"。 "h1" 的格式化器的 ID 是 "brief"，而
"h2" 的格式化器的 ID 是 "precise"。


用户定义对象
------------

此架构支持用户定义对象作为处理程序、过滤器和格式化器。 （日志记录器的
不同实例不需要具有不同类型，因此这个配置架构并不支持用户定义日志记录器
类。）

Objects to be configured are described by dictionaries which detail
their configuration.  In some places, the logging system will be able
to infer from the context how an object is to be instantiated, but
when a user-defined object is to be instantiated, the system will not
know how to do this.  In order to provide complete flexibility for
user-defined object instantiation, the user needs to provide a
'factory' - a callable which is called with a configuration dictionary
and which returns the instantiated object. This is signalled by an
absolute import path to the factory being made available under the
special key "'()'".  Here's a concrete example:

   formatters:
     brief:
       format: '%(message)s'
     default:
       format: '%(asctime)s %(levelname)-8s %(name)-15s %(message)s'
       datefmt: '%Y-%m-%d %H:%M:%S'
     custom:
         (): my.package.customFormatterFactory
         bar: baz
         spam: 99.9
         answer: 42

The above YAML snippet defines three formatters.  The first, with id
"brief", is a standard "logging.Formatter" instance with the specified
format string.  The second, with id "default", has a longer format and
also defines the time format explicitly, and will result in a
"logging.Formatter" initialized with those two format strings.  Shown
in Python source form, the "brief" and "default" formatters have
configuration sub-dictionaries:

   {
     'format' : '%(message)s'
   }

和:

   {
     'format' : '%(asctime)s %(levelname)-8s %(name)-15s %(message)s',
     'datefmt' : '%Y-%m-%d %H:%M:%S'
   }

respectively, and as these dictionaries do not contain the special key
"'()'", the instantiation is inferred from the context: as a result,
standard "logging.Formatter" instances are created.  The configuration
sub-dictionary for the third formatter, with id "custom", is:

   {
     '()' : 'my.package.customFormatterFactory',
     'bar' : 'baz',
     'spam' : 99.9,
     'answer' : 42
   }

and this contains the special key "'()'", which means that user-
defined instantiation is wanted.  In this case, the specified factory
callable will be used. If it is an actual callable it will be used
directly - otherwise, if you specify a string (as in the example) the
actual callable will be located using normal import mechanisms. The
callable will be called with the **remaining** items in the
configuration sub-dictionary as keyword arguments.  In the above
example, the formatter with id "custom" will be assumed to be returned
by the call:

   my.package.customFormatterFactory(bar='baz', spam=99.9, answer=42)

The key "'()'" has been used as the special key because it is not a
valid keyword parameter name, and so will not clash with the names of
the keyword arguments used in the call.  The "'()'" also serves as a
mnemonic that the corresponding value is a callable.


Access to external objects
--------------------------

There are times where a configuration needs to refer to objects
external to the configuration, for example "sys.stderr".  If the
configuration dict is constructed using Python code, this is
straightforward, but a problem arises when the configuration is
provided via a text file (e.g. JSON, YAML).  In a text file, there is
no standard way to distinguish "sys.stderr" from the literal string
"'sys.stderr'".  To facilitate this distinction, the configuration
system looks for certain special prefixes in string values and treat
them specially.  For example, if the literal string
"'ext://sys.stderr'" is provided as a value in the configuration, then
the "ext://" will be stripped off and the remainder of the value
processed using normal import mechanisms.

The handling of such prefixes is done in a way analogous to protocol
handling: there is a generic mechanism to look for prefixes which
match the regular expression "^(?P<prefix>[a-z]+)://(?P<suffix>.*)$"
whereby, if the "prefix" is recognised, the "suffix" is processed in a
prefix-dependent manner and the result of the processing replaces the
string value.  If the prefix is not recognised, then the string value
will be left as-is.


Access to internal objects
--------------------------

As well as external objects, there is sometimes also a need to refer
to objects in the configuration.  This will be done implicitly by the
configuration system for things that it knows about.  For example, the
string value "'DEBUG'" for a "level" in a logger or handler will
automatically be converted to the value "logging.DEBUG", and the
"handlers", "filters" and "formatter" entries will take an object id
and resolve to the appropriate destination object.

However, a more generic mechanism is needed for user-defined objects
which are not known to the "logging" module.  For example, consider
"logging.handlers.MemoryHandler", which takes a "target" argument
which is another handler to delegate to. Since the system already
knows about this class, then in the configuration, the given "target"
just needs to be the object id of the relevant target handler, and the
system will resolve to the handler from the id.  If, however, a user
defines a "my.package.MyHandler" which has an "alternate" handler, the
configuration system would not know that the "alternate" referred to a
handler.  To cater for this, a generic resolution system allows the
user to specify:

   handlers:
     file:
       # configuration of file handler goes here

     custom:
       (): my.package.MyHandler
       alternate: cfg://handlers.file

The literal string "'cfg://handlers.file'" will be resolved in an
analogous way to strings with the "ext://" prefix, but looking in the
configuration itself rather than the import namespace.  The mechanism
allows access by dot or by index, in a similar way to that provided by
"str.format".  Thus, given the following snippet:

   handlers:
     email:
       class: logging.handlers.SMTPHandler
       mailhost: localhost
       fromaddr: my_app@domain.tld
       toaddrs:
         - support_team@domain.tld
         - dev_team@domain.tld
       subject: Houston, we have a problem.

in the configuration, the string "'cfg://handlers'" would resolve to
the dict with key "handlers", the string "'cfg://handlers.email" would
resolve to the dict with key "email" in the "handlers" dict, and so
on.  The string "'cfg://handlers.email.toaddrs[1]" would resolve to
"'dev_team.domain.tld'" and the string
"'cfg://handlers.email.toaddrs[0]'" would resolve to the value
"'support_team@domain.tld'". The "subject" value could be accessed
using either "'cfg://handlers.email.subject'" or, equivalently,
"'cfg://handlers.email[subject]'".  The latter form only needs to be
used if the key contains spaces or non-alphanumeric characters.  If an
index value consists only of decimal digits, access will be attempted
using the corresponding integer value, falling back to the string
value if needed.

Given a string "cfg://handlers.myhandler.mykey.123", this will resolve
to "config_dict['handlers']['myhandler']['mykey']['123']". If the
string is specified as "cfg://handlers.myhandler.mykey[123]", the
system will attempt to retrieve the value from
"config_dict['handlers']['myhandler']['mykey'][123]", and fall back to
"config_dict['handlers']['myhandler']['mykey']['123']" if that fails.


Import resolution and custom importers
--------------------------------------

Import resolution, by default, uses the builtin "__import__()"
function to do its importing. You may want to replace this with your
own importing mechanism: if so, you can replace the "importer"
attribute of the "DictConfigurator" or its superclass, the
"BaseConfigurator" class. However, you need to be careful because of
the way functions are accessed from classes via descriptors. If you
are using a Python callable to do your imports, and you want to define
it at class level rather than instance level, you need to wrap it with
"staticmethod()". For example:

   from importlib import import_module
   from logging.config import BaseConfigurator

   BaseConfigurator.importer = staticmethod(import_module)

You don't need to wrap with "staticmethod()" if you're setting the
import callable on a configurator *instance*.


Configuration file format
=========================

The configuration file format understood by "fileConfig()" is based on
"configparser" functionality. The file must contain sections called
"[loggers]", "[handlers]" and "[formatters]" which identify by name
the entities of each type which are defined in the file. For each such
entity, there is a separate section which identifies how that entity
is configured.  Thus, for a logger named "log01" in the "[loggers]"
section, the relevant configuration details are held in a section
"[logger_log01]". Similarly, a handler called "hand01" in the
"[handlers]" section will have its configuration held in a section
called "[handler_hand01]", while a formatter called "form01" in the
"[formatters]" section will have its configuration specified in a
section called "[formatter_form01]". The root logger configuration
must be specified in a section called "[logger_root]".

注解:

  The "fileConfig()" API is older than the "dictConfig()" API and does
  not provide functionality to cover certain aspects of logging. For
  example, you cannot configure "Filter" objects, which provide for
  filtering of messages beyond simple integer levels, using
  "fileConfig()". If you need to have instances of "Filter" in your
  logging configuration, you will need to use "dictConfig()". Note
  that future enhancements to configuration functionality will be
  added to "dictConfig()", so it's worth considering transitioning to
  this newer API when it's convenient to do so.

Examples of these sections in the file are given below.

   [loggers]
   keys=root,log02,log03,log04,log05,log06,log07

   [handlers]
   keys=hand01,hand02,hand03,hand04,hand05,hand06,hand07,hand08,hand09

   [formatters]
   keys=form01,form02,form03,form04,form05,form06,form07,form08,form09

The root logger must specify a level and a list of handlers. An
example of a root logger section is given below.

   [logger_root]
   level=NOTSET
   handlers=hand01

The "level" entry can be one of "DEBUG, INFO, WARNING, ERROR,
CRITICAL" or "NOTSET". For the root logger only, "NOTSET" means that
all messages will be logged. Level values are "eval()"uated in the
context of the "logging" package's namespace.

The "handlers" entry is a comma-separated list of handler names, which
must appear in the "[handlers]" section. These names must appear in
the "[handlers]" section and have corresponding sections in the
configuration file.

For loggers other than the root logger, some additional information is
required. This is illustrated by the following example.

   [logger_parser]
   level=DEBUG
   handlers=hand01
   propagate=1
   qualname=compiler.parser

The "level" and "handlers" entries are interpreted as for the root
logger, except that if a non-root logger's level is specified as
"NOTSET", the system consults loggers higher up the hierarchy to
determine the effective level of the logger. The "propagate" entry is
set to 1 to indicate that messages must propagate to handlers higher
up the logger hierarchy from this logger, or 0 to indicate that
messages are **not** propagated to handlers up the hierarchy. The
"qualname" entry is the hierarchical channel name of the logger, that
is to say the name used by the application to get the logger.

Sections which specify handler configuration are exemplified by the
following.

   [handler_hand01]
   class=StreamHandler
   level=NOTSET
   formatter=form01
   args=(sys.stdout,)

The "class" entry indicates the handler's class (as determined by
"eval()" in the "logging" package's namespace). The "level" is
interpreted as for loggers, and "NOTSET" is taken to mean 'log
everything'.

The "formatter" entry indicates the key name of the formatter for this
handler. If blank, a default formatter ("logging._defaultFormatter")
is used. If a name is specified, it must appear in the "[formatters]"
section and have a corresponding section in the configuration file.

The "args" entry, when "eval()"uated in the context of the "logging"
package's namespace, is the list of arguments to the constructor for
the handler class. Refer to the constructors for the relevant
handlers, or to the examples below, to see how typical entries are
constructed. If not provided, it defaults to "()".

The optional "kwargs" entry, when "eval()"uated in the context of the
"logging" package's namespace, is the keyword argument dict to the
constructor for the handler class. If not provided, it defaults to
"{}".

   [handler_hand02]
   class=FileHandler
   level=DEBUG
   formatter=form02
   args=('python.log', 'w')

   [handler_hand03]
   class=handlers.SocketHandler
   level=INFO
   formatter=form03
   args=('localhost', handlers.DEFAULT_TCP_LOGGING_PORT)

   [handler_hand04]
   class=handlers.DatagramHandler
   level=WARN
   formatter=form04
   args=('localhost', handlers.DEFAULT_UDP_LOGGING_PORT)

   [handler_hand05]
   class=handlers.SysLogHandler
   level=ERROR
   formatter=form05
   args=(('localhost', handlers.SYSLOG_UDP_PORT), handlers.SysLogHandler.LOG_USER)

   [handler_hand06]
   class=handlers.NTEventLogHandler
   level=CRITICAL
   formatter=form06
   args=('Python Application', '', 'Application')

   [handler_hand07]
   class=handlers.SMTPHandler
   level=WARN
   formatter=form07
   args=('localhost', 'from@abc', ['user1@abc', 'user2@xyz'], 'Logger Subject')
   kwargs={'timeout': 10.0}

   [handler_hand08]
   class=handlers.MemoryHandler
   level=NOTSET
   formatter=form08
   target=
   args=(10, ERROR)

   [handler_hand09]
   class=handlers.HTTPHandler
   level=NOTSET
   formatter=form09
   args=('localhost:9022', '/log', 'GET')
   kwargs={'secure': True}

Sections which specify formatter configuration are typified by the
following.

   [formatter_form01]
   format=F1 %(asctime)s %(levelname)s %(message)s
   datefmt=
   class=logging.Formatter

The "format" entry is the overall format string, and the "datefmt"
entry is the "strftime()"-compatible date/time format string.  If
empty, the package substitutes something which is almost equivalent to
specifying the date format string "'%Y-%m-%d %H:%M:%S'".  This format
also specifies milliseconds, which are appended to the result of using
the above format string, with a comma separator.  An example time in
this format is "2003-01-23 00:29:50,411".

The "class" entry is optional.  It indicates the name of the
formatter's class (as a dotted module and class name.)  This option is
useful for instantiating a "Formatter" subclass.  Subclasses of
"Formatter" can present exception tracebacks in an expanded or
condensed format.

注解:

  Due to the use of "eval()" as described above, there are potential
  security risks which result from using the "listen()" to send and
  receive configurations via sockets. The risks are limited to where
  multiple users with no mutual trust run code on the same machine;
  see the "listen()" documentation for more information.

参见:

  模块 "logging"
     日志记录模块的 API 参考。

  "logging.handlers" 模块
     日志记录模块附带的有用处理器。
