创新互联Python教程：日志操作手册

日志操作手册

作者

创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于网站建设、成都网站设计、北流网络推广、微信平台小程序开发、北流网络营销、北流企业策划、北流品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联公司为所有大学生创业者提供北流建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com

Vinay Sajip

This page contains a number of recipes related to logging, which have been found useful in the past. For links to tutorial and reference information, please see 其他资源.

在多个模块中记录日志

无论对 logging.getLogger('someLogger') 进行多少次调用，都会返回同一个 logger 对象的引用。不仅在同一个模块内如此，只要是在同一个 python 解释器进程中，跨模块调用也是一样。同样是引用同一个对象，应用程序也可以在一个模块中定义和配置一个父 logger，而在另一个单独的模块中创建（但不配置）子 logger，对于子 logger 的所有调用都会传给父 logger。以下是主模块：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
  2. import auxiliary_module
    3.   
  
  
  
    4.   
  
  
  
  4. # create logger with 'spam_application'
    5.   
  
  
  
  5. logger = logging.getLogger('spam_application')
    6.   
  
  
  
  6. logger.setLevel(logging.DEBUG)
    7.   
  
  
  
  7. # create file handler which logs even debug messages
    8.   
  
  
  
  8. fh = logging.FileHandler('spam.log')
    9.   
  
  
  
  9. fh.setLevel(logging.DEBUG)
    10.   
  
  
  
  10. # create console handler with a higher log level
    11.   
  
  
  
  11. ch = logging.StreamHandler()
    12.   
  
  
  
  12. ch.setLevel(logging.ERROR)
    13.   
  
  
  
  13. # create formatter and add it to the handlers
    14.   
  
  
  
  14. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    15.   
  
  
  
  15. fh.setFormatter(formatter)
    16.   
  
  
  
  16. ch.setFormatter(formatter)
    17.   
  
  
  
  17. # add the handlers to the logger
    18.   
  
  
  
  18. logger.addHandler(fh)
    19.   
  
  
  
  19. logger.addHandler(ch)
    20.   
  
  
  
    21.   
  
  
  
  21. logger.info('creating an instance of auxiliary_module.Auxiliary')
    22.   
  
  
  
  22. a = auxiliary_module.Auxiliary()
    23.   
  
  
  
  23. logger.info('created an instance of auxiliary_module.Auxiliary')
    24.   
  
  
  
  24. logger.info('calling auxiliary_module.Auxiliary.do_something')
    25.   
  
  
  
  25. a.do_something()
    26.   
  
  
  
  26. logger.info('finished auxiliary_module.Auxiliary.do_something')
    27.   
  
  
  
  27. logger.info('calling auxiliary_module.some_function()')
    28.   
  
  
  
  28. auxiliary_module.some_function()
    29.   
  
  
  
  29. logger.info('done with auxiliary_module.some_function()')
    30.

以下是辅助模块：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
    3.   
  
  
  
  3. # create logger
    4.   
  
  
  
  4. module_logger = logging.getLogger('spam_application.auxiliary')
    5.   
  
  
  
    6.   
  
  
  
  6. class Auxiliary:
    7.   
  
  
  
  7.  def __init__(self):
    8.   
  
  
  
  8.  self.logger = logging.getLogger('spam_application.auxiliary.Auxiliary')
    9.   
  
  
  
  9.  self.logger.info('creating an instance of Auxiliary')
    10.   
  
  
  
    11.   
  
  
  
  11.  def do_something(self):
    12.   
  
  
  
  12.  self.logger.info('doing something')
    13.   
  
  
  
  13.  a = 1 + 1
    14.   
  
  
  
  14.  self.logger.info('done doing something')
    15.   
  
  
  
    16.   
  
  
  
  16. def some_function():
    17.   
  
  
  
  17.  module_logger.info('received a call to "some_function"')
    18.

输出结果会像这样:

 
 
 
 
    
  
  
  
  
  1. 2005-03-23 23:47:11,663 - spam_application - INFO -
    2.   
  
  
  
  2.  creating an instance of auxiliary_module.Auxiliary
    3.   
  
  
  
  3. 2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
    4.   
  
  
  
  4.  creating an instance of Auxiliary
    5.   
  
  
  
  5. 2005-03-23 23:47:11,665 - spam_application - INFO -
    6.   
  
  
  
  6.  created an instance of auxiliary_module.Auxiliary
    7.   
  
  
  
  7. 2005-03-23 23:47:11,668 - spam_application - INFO -
    8.   
  
  
  
  8.  calling auxiliary_module.Auxiliary.do_something
    9.   
  
  
  
  9. 2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
    10.   
  
  
  
  10.  doing something
    11.   
  
  
  
  11. 2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
    12.   
  
  
  
  12.  done doing something
    13.   
  
  
  
  13. 2005-03-23 23:47:11,670 - spam_application - INFO -
    14.   
  
  
  
  14.  finished auxiliary_module.Auxiliary.do_something
    15.   
  
  
  
  15. 2005-03-23 23:47:11,671 - spam_application - INFO -
    16.   
  
  
  
  16.  calling auxiliary_module.some_function()
    17.   
  
  
  
  17. 2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
    18.   
  
  
  
  18.  received a call to 'some_function'
    19.   
  
  
  
  19. 2005-03-23 23:47:11,673 - spam_application - INFO -
    20.   
  
  
  
  20.  done with auxiliary_module.some_function()
    21.

在多个线程中记录日志

多线程记录日志并不需要特殊处理，以下示例演示了在主线程（起始线程）和其他线程中记录日志的过程：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
  2. import threading
    3.   
  
  
  
  3. import time
    4.   
  
  
  
    5.   
  
  
  
  5. def worker(arg):
    6.   
  
  
  
  6.  while not arg['stop']:
    7.   
  
  
  
  7.  logging.debug('Hi from myfunc')
    8.   
  
  
  
  8.  time.sleep(0.5)
    9.   
  
  
  
    10.   
  
  
  
  10. def main():
    11.   
  
  
  
  11.  logging.basicConfig(level=logging.DEBUG, format='%(relativeCreated)6d %(threadName)s %(message)s')
    12.   
  
  
  
  12.  info = {'stop': False}
    13.   
  
  
  
  13.  thread = threading.Thread(target=worker, args=(info,))
    14.   
  
  
  
  14.  thread.start()
    15.   
  
  
  
  15.  while True:
    16.   
  
  
  
  16.  try:
    17.   
  
  
  
  17.  logging.debug('Hello from main')
    18.   
  
  
  
  18.  time.sleep(0.75)
    19.   
  
  
  
  19.  except KeyboardInterrupt:
    20.   
  
  
  
  20.  info['stop'] = True
    21.   
  
  
  
  21.  break
    22.   
  
  
  
  22.  thread.join()
    23.   
  
  
  
    24.   
  
  
  
  24. if __name__ == '__main__':
    25.   
  
  
  
  25.  main()
    26.

脚本会运行输出类似下面的内容:

 
 
 
 
    
  
  
  
  
  1.  0 Thread-1 Hi from myfunc
    2.   
  
  
  
  2.  3 MainThread Hello from main
    3.   
  
  
  
  3.  505 Thread-1 Hi from myfunc
    4.   
  
  
  
  4.  755 MainThread Hello from main
    5.   
  
  
  
  5. 1007 Thread-1 Hi from myfunc
    6.   
  
  
  
  6. 1507 MainThread Hello from main
    7.   
  
  
  
  7. 1508 Thread-1 Hi from myfunc
    8.   
  
  
  
  8. 2010 Thread-1 Hi from myfunc
    9.   
  
  
  
  9. 2258 MainThread Hello from main
    10.   
  
  
  
  10. 2512 Thread-1 Hi from myfunc
    11.   
  
  
  
  11. 3009 MainThread Hello from main
    12.   
  
  
  
  12. 3013 Thread-1 Hi from myfunc
    13.   
  
  
  
  13. 3515 Thread-1 Hi from myfunc
    14.   
  
  
  
  14. 3761 MainThread Hello from main
    15.   
  
  
  
  15. 4017 Thread-1 Hi from myfunc
    16.   
  
  
  
  16. 4513 MainThread Hello from main
    17.   
  
  
  
  17. 4518 Thread-1 Hi from myfunc
    18.

以上如期显示了不同线程的日志是交替输出的。当然更多的线程也会如此。

多个 handler 和多种 formatter

日志是个普通的 Python 对象。 addHandler() 方法可加入不限数量的日志 handler。有时候，应用程序需把严重错误信息记入文本文件，而将一般错误或其他级别的信息输出到控制台。若要进行这样的设定，只需多配置几个日志 handler 即可，应用程序的日志调用代码可以保持不变。下面对之前的分模块日志示例略做修改：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
    3.   
  
  
  
  3. logger = logging.getLogger('simple_example')
    4.   
  
  
  
  4. logger.setLevel(logging.DEBUG)
    5.   
  
  
  
  5. # create file handler which logs even debug messages
    6.   
  
  
  
  6. fh = logging.FileHandler('spam.log')
    7.   
  
  
  
  7. fh.setLevel(logging.DEBUG)
    8.   
  
  
  
  8. # create console handler with a higher log level
    9.   
  
  
  
  9. ch = logging.StreamHandler()
    10.   
  
  
  
  10. ch.setLevel(logging.ERROR)
    11.   
  
  
  
  11. # create formatter and add it to the handlers
    12.   
  
  
  
  12. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    13.   
  
  
  
  13. ch.setFormatter(formatter)
    14.   
  
  
  
  14. fh.setFormatter(formatter)
    15.   
  
  
  
  15. # add the handlers to logger
    16.   
  
  
  
  16. logger.addHandler(ch)
    17.   
  
  
  
  17. logger.addHandler(fh)
    18.   
  
  
  
    19.   
  
  
  
  19. # 'application' code
    20.   
  
  
  
  20. logger.debug('debug message')
    21.   
  
  
  
  21. logger.info('info message')
    22.   
  
  
  
  22. logger.warning('warn message')
    23.   
  
  
  
  23. logger.error('error message')
    24.   
  
  
  
  24. logger.critical('critical message')
    25.

需要注意的是，“应用程序”内的代码并不关心是否存在多个日志 handler。示例中所做的改变，只是新加入并配置了一个名为 fh 的 handler。

在编写和测试应用程序时，若能创建日志 handler 对不同严重级别的日志信息进行过滤，这将十分有用。调试时无需用多条 print 语句，而是采用 logger.debug ：print 语句以后还得注释或删掉，而 logger.debug 语句可以原样留在源码中保持静默。当需要再次调试时，只要改变日志对象或 handler 的严重级别即可。

在多个地方记录日志

假定要根据不同的情况将日志以不同的格式写入控制台和文件。比如把 DEBUG 以上级别的日志信息写于文件，并且把 INFO 以上的日志信息输出到控制台。再假设日志文件需要包含时间戳，控制台信息则不需要。以下演示了做法：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
    3.   
  
  
  
  3. # set up logging to file - see previous section for more details
    4.   
  
  
  
  4. logging.basicConfig(level=logging.DEBUG,
    5.   
  
  
  
  5.  format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
    6.   
  
  
  
  6.  datefmt='%m-%d %H:%M',
    7.   
  
  
  
  7.  filename='/tmp/myapp.log',
    8.   
  
  
  
  8.  filemode='w')
    9.   
  
  
  
  9. # define a Handler which writes INFO messages or higher to the sys.stderr
    10.   
  
  
  
  10. console = logging.StreamHandler()
    11.   
  
  
  
  11. console.setLevel(logging.INFO)
    12.   
  
  
  
  12. # set a format which is simpler for console use
    13.   
  
  
  
  13. formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
    14.   
  
  
  
  14. # tell the handler to use this format
    15.   
  
  
  
  15. console.setFormatter(formatter)
    16.   
  
  
  
  16. # add the handler to the root logger
    17.   
  
  
  
  17. logging.getLogger('').addHandler(console)
    18.   
  
  
  
    19.   
  
  
  
  19. # Now, we can log to the root logger, or any other logger. First the root...
    20.   
  
  
  
  20. logging.info('Jackdaws love my big sphinx of quartz.')
    21.   
  
  
  
    22.   
  
  
  
  22. # Now, define a couple of other loggers which might represent areas in your
    23.   
  
  
  
  23. # application:
    24.   
  
  
  
    25.   
  
  
  
  25. logger1 = logging.getLogger('myapp.area1')
    26.   
  
  
  
  26. logger2 = logging.getLogger('myapp.area2')
    27.   
  
  
  
    28.   
  
  
  
  28. logger1.debug('Quick zephyrs blow, vexing daft Jim.')
    29.   
  
  
  
  29. logger1.info('How quickly daft jumping zebras vex.')
    30.   
  
  
  
  30. logger2.warning('Jail zesty vixen who grabbed pay from quack.')
    31.   
  
  
  
  31. logger2.error('The five boxing wizards jump quickly.')
    32.

当运行后，你会看到控制台如下所示

 
 
 
 
    
  
  
  
  
  1. root : INFO Jackdaws love my big sphinx of quartz.
    2.   
  
  
  
  2. myapp.area1 : INFO How quickly daft jumping zebras vex.
    3.   
  
  
  
  3. myapp.area2 : WARNING Jail zesty vixen who grabbed pay from quack.
    4.   
  
  
  
  4. myapp.area2 : ERROR The five boxing wizards jump quickly.
    5.

而日志文件将如下所示：

 
 
 
 
    
  
  
  
  
  1. 10-22 22:19 root INFO Jackdaws love my big sphinx of quartz.
    2.   
  
  
  
  2. 10-22 22:19 myapp.area1 DEBUG Quick zephyrs blow, vexing daft Jim.
    3.   
  
  
  
  3. 10-22 22:19 myapp.area1 INFO How quickly daft jumping zebras vex.
    4.   
  
  
  
  4. 10-22 22:19 myapp.area2 WARNING Jail zesty vixen who grabbed pay from quack.
    5.   
  
  
  
  5. 10-22 22:19 myapp.area2 ERROR The five boxing wizards jump quickly.
    6.

如您所见，DEBUG 级别的日志信息只出现在了文件中，而其他信息则两个地方都会输出。

上述示例只用到了控制台和文件 handler，当然还可以自由组合任意数量的日志 handler。

Note that the above choice of log filename /tmp/myapp.log implies use of a standard location for temporary files on POSIX systems. On Windows, you may need to choose a different directory name for the log - just ensure that the directory exists and that you have the permissions to create and update files in it.

Custom handling of levels

Sometimes, you might want to do something slightly different from the standard handling of levels in handlers, where all levels above a threshold get processed by a handler. To do this, you need to use filters. Let’s look at a scenario where you want to arrange things as follows:

  • Send messages of severity INFO and WARNING to sys.stdout

  • Send messages of severity ERROR and above to sys.stderr

  • Send messages of severity DEBUG and above to file app.log

Suppose you configure logging with the following JSON:

 
 
 
 
    
  
  
  
  
  1. {
    2.   
  
  
  
  2.  "version": 1,
    3.   
  
  
  
  3.  "disable_existing_loggers": false,
    4.   
  
  
  
  4.  "formatters": {
    5.   
  
  
  
  5.  "simple": {
    6.   
  
  
  
  6.  "format": "%(levelname)-8s - %(message)s"
    7.   
  
  
  
  7.  }
    8.   
  
  
  
  8.  },
    9.   
  
  
  
  9.  "handlers": {
    10.   
  
  
  
  10.  "stdout": {
    11.   
  
  
  
  11.  "class": "logging.StreamHandler",
    12.   
  
  
  
  12.  "level": "INFO",
    13.   
  
  
  
  13.  "formatter": "simple",
    14.   
  
  
  
  14.  "stream": "ext://sys.stdout",
    15.   
  
  
  
  15.  },
    16.   
  
  
  
  16.  "stderr": {
    17.   
  
  
  
  17.  "class": "logging.StreamHandler",
    18.   
  
  
  
  18.  "level": "ERROR",
    19.   
  
  
  
  19.  "formatter": "simple",
    20.   
  
  
  
  20.  "stream": "ext://sys.stderr"
    21.   
  
  
  
  21.  },
    22.   
  
  
  
  22.  "file": {
    23.   
  
  
  
  23.  "class": "logging.FileHandler",
    24.   
  
  
  
  24.  "formatter": "simple",
    25.   
  
  
  
  25.  "filename": "app.log",
    26.   
  
  
  
  26.  "mode": "w"
    27.   
  
  
  
  27.  }
    28.   
  
  
  
  28.  },
    29.   
  
  
  
  29.  "root": {
    30.   
  
  
  
  30.  "level": "DEBUG",
    31.   
  
  
  
  31.  "handlers": [
    32.   
  
  
  
  32.  "stderr",
    33.   
  
  
  
  33.  "stdout",
    34.   
  
  
  
  34.  "file"
    35.   
  
  
  
  35.  ]
    36.   
  
  
  
  36.  }
    37.   
  
  
  
  37. }
    38.

This configuration does almost what we want, except that sys.stdout would show messages of severity ERROR and above as well as INFO and WARNING messages. To prevent this, we can set up a filter which excludes those messages and add it to the relevant handler. This can be configured by adding a filters section parallel to formatters and handlers:

 
 
 
 
    
  
  
  
  
  1. "filters": {
    2.   
  
  
  
  2.  "warnings_and_below": {
    3.   
  
  
  
  3.  "()" : "__main__.filter_maker",
    4.   
  
  
  
  4.  "level": "WARNING"
    5.   
  
  
  
  5.  }
    6.   
  
  
  
  6. }
    7.

and changing the section on the stdout handler to add it:

 
 
 
 
    
  
  
  
  
  1. "stdout": {
    2.   
  
  
  
  2.  "class": "logging.StreamHandler",
    3.   
  
  
  
  3.  "level": "INFO",
    4.   
  
  
  
  4.  "formatter": "simple",
    5.   
  
  
  
  5.  "stream": "ext://sys.stdout",
    6.   
  
  
  
  6.  "filters": ["warnings_and_below"]
    7.   
  
  
  
  7. }
    8.

A filter is just a function, so we can define the filter_maker (a factory function) as follows:

 
 
 
 
    
  
  
  
  
  1. def filter_maker(level):
    2.   
  
  
  
  2.  level = getattr(logging, level)
    3.   
  
  
  
    4.   
  
  
  
  4.  def filter(record):
    5.   
  
  
  
  5.  return record.levelno <= level
    6.   
  
  
  
    7.   
  
  
  
  7.  return filter
    8.

This converts the string argument passed in to a numeric level, and returns a function which only returns True if the level of the passed in record is at or below the specified level. Note that in this example I have defined the filter_maker in a test script main.py that I run from the command line, so its module will be __main__ - hence the __main__.filter_maker in the filter configuration. You will need to change that if you define it in a different module.

With the filter added, we can run main.py, which in full is:

 
 
 
 
    
  
  
  
  
  1. import json
    2.   
  
  
  
  2. import logging
    3.   
  
  
  
  3. import logging.config
    4.   
  
  
  
    5.   
  
  
  
  5. CONFIG = '''
    6.   
  
  
  
  6. {
    7.   
  
  
  
  7.  "version": 1,
    8.   
  
  
  
  8.  "disable_existing_loggers": false,
    9.   
  
  
  
  9.  "formatters": {
    10.   
  
  
  
  10.  "simple": {
    11.   
  
  
  
  11.  "format": "%(levelname)-8s - %(message)s"
    12.   
  
  
  
  12.  }
    13.   
  
  
  
  13.  },
    14.   
  
  
  
  14.  "filters": {
    15.   
  
  
  
  15.  "warnings_and_below": {
    16.   
  
  
  
  16.  "()" : "__main__.filter_maker",
    17.   
  
  
  
  17.  "level": "WARNING"
    18.   
  
  
  
  18.  }
    19.   
  
  
  
  19.  },
    20.   
  
  
  
  20.  "handlers": {
    21.   
  
  
  
  21.  "stdout": {
    22.   
  
  
  
  22.  "class": "logging.StreamHandler",
    23.   
  
  
  
  23.  "level": "INFO",
    24.   
  
  
  
  24.  "formatter": "simple",
    25.   
  
  
  
  25.  "stream": "ext://sys.stdout",
    26.   
  
  
  
  26.  "filters": ["warnings_and_below"]
    27.   
  
  
  
  27.  },
    28.   
  
  
  
  28.  "stderr": {
    29.   
  
  
  
  29.  "class": "logging.StreamHandler",
    30.   
  
  
  
  30.  "level": "ERROR",
    31.   
  
  
  
  31.  "formatter": "simple",
    32.   
  
  
  
  32.  "stream": "ext://sys.stderr"
    33.   
  
  
  
  33.  },
    34.   
  
  
  
  34.  "file": {
    35.   
  
  
  
  35.  "class": "logging.FileHandler",
    36.   
  
  
  
  36.  "formatter": "simple",
    37.   
  
  
  
  37.  "filename": "app.log",
    38.   
  
  
  
  38.  "mode": "w"
    39.   
  
  
  
  39.  }
    40.   
  
  
  
  40.  },
    41.   
  
  
  
  41.  "root": {
    42.   
  
  
  
  42.  "level": "DEBUG",
    43.   
  
  
  
  43.  "handlers": [
    44.   
  
  
  
  44.  "stderr",
    45.   
  
  
  
  45.  "stdout",
    46.   
  
  
  
  46.  "file"
    47.   
  
  
  
  47.  ]
    48.   
  
  
  
  48.  }
    49.   
  
  
  
  49. }
    50.   
  
  
  
  50. '''
    51.   
  
  
  
    52.   
  
  
  
  52. def filter_maker(level):
    53.   
  
  
  
  53.  level = getattr(logging, level)
    54.   
  
  
  
    55.   
  
  
  
  55.  def filter(record):
    56.   
  
  
  
  56.  return record.levelno <= level
    57.   
  
  
  
    58.   
  
  
  
  58.  return filter
    59.   
  
  
  
    60.   
  
  
  
  60. logging.config.dictConfig(json.loads(CONFIG))
    61.   
  
  
  
  61. logging.debug('A DEBUG message')
    62.   
  
  
  
  62. logging.info('An INFO message')
    63.   
  
  
  
  63. logging.warning('A WARNING message')
    64.   
  
  
  
  64. logging.error('An ERROR message')
    65.   
  
  
  
  65. logging.critical('A CRITICAL message')
    66.

And after running it like this:

 
 
 
 
    
  
  
  
  
  1. python main.py 2>stderr.log >stdout.log
    2.

We can see the results are as expected:

 
 
 
 
    
  
  
  
  
  1. $ more *.log
    2.   
  
  
  
  2. ::::::::::::::
    3.   
  
  
  
  3. app.log
    4.   
  
  
  
  4. ::::::::::::::
    5.   
  
  
  
  5. DEBUG - A DEBUG message
    6.   
  
  
  
  6. INFO - An INFO message
    7.   
  
  
  
  7. WARNING - A WARNING message
    8.   
  
  
  
  8. ERROR - An ERROR message
    9.   
  
  
  
  9. CRITICAL - A CRITICAL message
    10.   
  
  
  
  10. ::::::::::::::
    11.   
  
  
  
  11. stderr.log
    12.   
  
  
  
  12. ::::::::::::::
    13.   
  
  
  
  13. ERROR - An ERROR message
    14.   
  
  
  
  14. CRITICAL - A CRITICAL message
    15.   
  
  
  
  15. ::::::::::::::
    16.   
  
  
  
  16. stdout.log
    17.   
  
  
  
  17. ::::::::::::::
    18.   
  
  
  
  18. INFO - An INFO message
    19.   
  
  
  
  19. WARNING - A WARNING message
    20.

日志配置服务器示例

以下是一个用到了日志配置服务器的模块示例：

 
 
 
 
    
  
  
  
  
  1. import logging
    2.   
  
  
  
  2. import logging.config
    3.   
  
  
  
  3. import time
    4.   
  
  
  
  4. import os
    5.   
  
  
  
    6.   
  
  
  
  6. # read initial config file
    7.   
  
  
  
  7. logging.config.fileConfig('logging.conf')
    8.   
  
  
  
    9.   
  
  
  
  9. # create and start listener on port 9999
    10.   
  
  
  
  10. t = logging.config.listen(9999)
    11.   
  
  
  
  11. t.start()
    12.   
  
  
  
    13.   
  
  
  
  13. logger = logging.getLogger('simpleExample')
    14.   
  
  
  
    15.   
  
  
  
  15. try:
    16.   
  
  
  
  16.  # loop through logging calls to see the difference
    17.   
  
  
  
  17.  # new configurations make, until Ctrl+C is pressed
    18.   
  
  
  
  18.  while True:
    19.   
  
  
  
  19.  logger.debug('debug message')
    20.   
  
  
  
  20.  logger.info('info message')
    21.   
  
  
  
  21.  logger.warning('warn message')
    22.   
  
  
  
  22.  logger.error('error message')
    23.   
  
  
  
  23.  logger.critical('critical message')
    24.   
  
  
  
  24.  time.sleep(5)
    25.   
  
  
  
  25. except KeyboardInterrupt:
    26.   
  
  
  
  26.  # cleanup
    27.   
  
  
  
  27.  logging.config.stopListening()
    28.   
  
  
  
  28.  t.join()
    29.

以下脚本将接受文件名作为参数，然后将此文件发送到服务器，前面加上文件的二进制编码长度，做为新的日志配置：

 
 
 
 
    
  
  
  
  
  1. #!/usr/bin/env python
    2.   
  
  
  
  2. import socket, sys, struct
    3.   
  
  
  
    4.   
  
  
  
  4. with open(sys.argv[1], 'rb') as f:
    5.   
  
  
  
  5.  data_to_send = f.read()
    6.   
  
  
  
    7.   
  
  
  
  7. HOST = 'localhost'
    8.   
  
  
  
  8. PORT = 9999
    9.   
  
  
  
  9. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    10.   
  
  
  
  10. print('connecting...')
    11.   
  
  
  
  11. s.connect((HOST, PORT))
    12.   
  
  
  
  12. print('sending config...')
    13.   
  
  
  
  13. s.send(struct.pack('>L', len(data_to_send)))
    14.   
  
  
  
  14. s.send(data_to_send)
    15.   
  
  
  
  15. s.close()
    16.   
  
  
  
  16. print('complete')
    17.

处理日志 handler 的阻塞

有时你必须让日志记录处理程序的运行不会阻塞你要记录日志的线程。 这在 Web 应用程序中是很常见，当然在其他场景中也可能发生。

有一种原因往往会让程序表现迟钝，这就是 SMTPHandler：由于很多因素是开发人员无法控制的（例如邮件或网络基础设施的性能不佳），发送电子邮件可能需要很长时间。不过几乎所有网络 handler 都可能会发生阻塞：即使是 SocketHandler 操作也可能在后台执行 DNS 查询，而这种查询实在太慢了（并且 DNS 查询还可能在很底层的套接字库代码中，位于 Python 层之下，超出了可控范围）。

有一种解决方案是分成两部分实现。第一部分，针对那些对性能有要求的关键线程，只为日志对象连接一个 QueueHandler。日志对象只需简单地写入队列即可，可为队列设置足够大的容量，或者可以在初始化时不设置容量上限。尽管为以防万一，可能需要在代码中捕获 queue.Full 异常,不过队列写入操作通常会很快得以处理。如果要开发库代码，包含性能要求较高的线程，为了让使用该库的开发人员受益，请务必在开发文档中进行标明（包括建议仅连接 QueueHandlers ）。

解决方案的另一部分就是 QueueListener，它被设计为 QueueHandler 的对应部分。QueueListener 非常简单：传入一个队列和一些 handler，并启动一个内部线程，用于侦听 QueueHandlers``（或其他 ``LogRecords 源）发送的 LogRecord 队列。LogRecords 会从队列中移除并传给 handler 处理。

QueueListener 作为单独的类，好处就是可以用同一个实例为多个 QueueHandlers 服务。这比把现有 handler 类线程化更加资源友好，后者会每个 handler 会占用一个线程，却没有特别的好处。

以下是这两个类的运用示例（省略了 import 语句）：

 
 
 
 
    
  
  
  
  
  1. que = queue.Queue(-1) # no limit on size
    2.   
  
  
  
  2. queue_handler = QueueHandler(que)
    3.   
  
  
  
  3. handler = logging.StreamHandler()
    4.   
  
  
  
  4. listener = QueueListener(que, handler)
    5.   
  
  
  
  5. root = logging.getLogger()
    6.   
  
  
  
  6. root.addHandler(queue_handler)
    7.   
  
  
  
  7. formatter = logging.Formatter('%(threadName)s: %(message)s')
    8.   
  
  
  
  8. handler.setFormatter(formatter)
    9.   
  
  
  
  9. listener.start()
    10.   
  
  
  
  10. # The log output will display the thread which generated
    11.   
  
  
  
  11. # the event (the main thread) rather than the internal
    12.   
  
  
  
  12. # thread which monitors the internal queue. This is what
    13.   
  
  
  
  13. # you want to happen.
    14.   
  
  
  
  14. root.warning('Look out!')
    15.   
  
  
  
  15. listener.stop()
    16.

在运行后会产生:

 
 
 
 
    
  
  
  
  
  1. MainThread: Look out!
    2.

备注

Although the earlier discussion wasn’t specifically talking about async code, but rather about slow logging handlers, it should be noted that when logging from async code, network and even file handlers could lead to problems (blocking the event loop) because some logging is done from asyncio internals. It might be best, if any async code is used in an application, to use the above approach for logging, so that any blocking code runs only in the QueueListener thread.

在 3.5 版更改: 在 Python 3.5 之前，QueueListener 总会把由队列接收到的每条信息都传递给已初始化的每个处理程序。（因为这里假定级别过滤操作已在写入队列时完成了。）从 3.5 版开始，可以修改这种处理方式，只要将关键字参数 respect_handler_level=True 传给侦听器的构造函数即可。这样侦听器将会把每条信息的级别与 handler 的级别进行比较，只在适配时才会将信息传给 handler 。

通过网络收发日志事件

假定现在要通过网络发送日志事件，并在接收端进行处理。有一种简单的方案，就是在发送端的根日志对象连接一个 SocketHandler 实例：

 
 
 
 
    
  
  
  
  
  1. import logging, logging.handlers
    2.   
  
  
  
    3.   
  
  
  
  3. rootLogger = logging.getLogger('')
    4.   
  
  
  
  4. rootLogger.setLevel(logging.DEBUG)
    5.   
  
  
  
  5. socketHandler = logging.handlers.SocketHandler('localhost',
    6.   
  
  
  
  6.  logging.handlers.DEFAULT_TCP_LOGGING_PORT)
    7.   
  
  
  
  7. # don't bother with a formatter, since a socket handler sends the event as
    8.   
  
  
  
  8. # an unformatted pickle
    9.   
  
  
  
  9. rootLogger.addHandler(socketHandler)
    10.   
  
  
  
    11.   
  
  
  
  11. # Now, we can log to the root logger, or any other logger. First the root...
    12.   
  
  
  
  12. logging.info('Jackdaws love my big sphinx of quartz.')
    13.   
  
  
  
    14.   
  
  
  
  14. # Now, define a couple of other loggers which might represent areas in your
    15.   
  
  
  
  15. # application:
    16.   
  
  
  
    17.   
  
  
  
  17. logger1 = logging.getLogger('myapp.area1')
    18.   
  
  
  
  18. logger2 = logging.getLogger('myapp.area2')
    19.   
  
  
  
    20.   
  
  
  
  20. logger1.debug('Quick zephyrs blow, vexing daft Jim.')
    21.   
  
  
  
  21. logger1.info('How quickly daft jumping zebras vex.')
    22.   
  
  
  
  22. logger2.warning('Jail zesty vixen who grabbed pay from quack.')
    23.   
  
  
  
  23. logger2.error('The five boxing wizards jump quickly.')
    24.

在接收端，可以用 socketserver 模块设置一个接收器。简要示例如下：

 
 
 
 
    
  
  
  
  
  1. import pickle
    2.   
  
  
  
  2. import logging
    3.   
  
  
  
  3. import logging.handlers
    4.   
  
  
  
  4. import socketserver
    5.   
  
  
  
  5. import struct
    6.   
  
  
  
    7.   
  
  
  
    8.   
  
  
  
  8. class LogRecordStreamHandler(socketserver.StreamRequestHandler):
    9.   
  
  
  
  9.  """Handler for a streaming logging request.
    10.   
  
  
  
    11.   
  
  
  
  11.  This basically logs the record using whatever logging policy is
    12.   
  
  
  
  12.  configured locally.
    13.   
  
  
  
  13.  """
    14.   
  
  
  
    15.   
  
  
  
  15.  def handle(self):
    16.   
  
  
  
  16.  """
    17.   
  
  
  
  17.  Handle multiple requests - each expected to be a 4-byte length,
    18.   
  
  
  
  18.  followed by the LogRecord in pickle format. Logs the record
    19.   
  
  
  
  19.  according to whatever policy is configured locally.
    20.   
  
  
  
  20.  """
    21.   
  
  
  
  21.  while True:
    22.   
  
  
  
  22.  chunk = self.connection.recv(4)
    23.   
  
  
  
  23.  if len(chunk) < 4:
    24.   
  
  
  
  24.  break
    25.   
  
  
  
  25.  slen = struct.unpack('>L', chunk)[0]
    26.   
  
  
  
  26.  chunk = self.connection.recv(slen)
    27.   
  
  
  
  27.  while len(chunk) < slen:
    28.   
  
  
  
  28.  chunk = chunk + self.connection.recv(slen - len(chunk))
    29.   
  
  
  
  29.  obj = self.unPickle(chunk)
    30.   
  
  
  
  30.  record = logging.makeLogRecord(obj)
    31.   
  
  
  
  31.  self.handleLogRecord(record)
    32.   
  
  
  
    33.   
  
  
  
  33.  def unPickle(self, data):
    34.   
  
  
  
  34.  return pickle.loads(data)
    35.   
  
  
  
    36.   
  
  
  
  36.  def handleLogRecord(self, record):
    37.   
  
  
  
  37.  # if a name is specified, we use the named logger rather than the one
    38.   
  
  
  
  38.  # implied by the record.
    39.   
  
  
  
  39.  if self.server.logname is not None:
    40.   
  
  
  
  40.  name = self.server.logname
    41.   
  
  
  
  41.  else:
    42.   
  
  
  
  42.  name = record.name
    43.   
  
  
  
  43.  logger = logging.getLogger(name)
    44.   
  
  
  
  44.  # N.B. EVERY record gets logged. This is because Logger.handle
    45.   
  
  
  
  45.  # is normally called AFTER logger-level filtering. If you want
    46.   
  
  
  
  46.  # to do filtering, do it at the client end to save wasting
    47.   
  
  
  
  47.  # cycles and network bandwidth!
    48.   
  
  
  
  48.  logger.handle(record)
    49.   
  
  
  
    50.   
  
  
  
  50. class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
    51.   
  
  
  
  51.  """
    52.   
  
  
  
  52.  Simple TCP socket-based logging receiver suitable for testing.
    53.   
  
  
  
  53.  """
    54.   
  
  
  
    55.   
  
  
  
  55.  allow_reuse_address = True
    56.   
  
  
  
    57.   
  
  
  
  57.  def __init__
                本文名称：创新互联Python教程：日志操作手册
                
    
                文章出自：http://www.36103.cn/qtweb/news41/5091.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

ChatGPT知识

分类信息网站

四川航空文化　　 　成都网站营销　　 　成都电商网站建设方案　　 　成都400电话办理　　 　四川主机托管　　 　绵阳主机托管　　 　成都网站优化　　 　手机网站建设套餐　　 　绵阳梓潼网站建设　　 　成都IDC机房托管　　 　成都木托盘　　 　简阳电信服务器托管　　 　谷歌优化排名　　 　成都名片印刷　　 　微信小程序开发　　 　成都企业网站设计　　 　广汉锦华　　 　成都圣月服饰　　 　深圳惠宜防蚊纱窗　　 　公司宣传册设计