logging概述

logging是软件运行过程中跟踪一些时间发生的一种手段，软件开发会在软件的一些特定时间发生后在代码中添加log，此时会调用logging。日志里面对这个事件信息进行描述，可以包含一些变量数据，具体信息由自己定义。这些事件也存在一定的严重程度，这些也是由开发者赋给事件的严重性，即会有一个时间的Level表示不同严重级别的事件。
基本配置：
logger = logging.getLogger(name)这里引申下name的意思：那么这时 name 的作用就彰显了，它可以标识模块的名字，具体可以看下如下文章name说明，如果是使用同一个名字，在日志里面会有重复打印的问题，具体可以参考：防止logging重复打印

import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")
>>>>
2016-10-09 19:11:19,434 - __main__ - INFO - Start print log
2016-10-09 19:11:19,434 - __main__ - WARNING - Something maybe fail.
2016-10-09 19:11:19,434 - __main__ - INFO - Finish

1. 场景 | 想要执行的任务 | 该任务适合的工具 | | —- | —- | | 一个命令行脚本或者程序的一般用法显示在console输出 | print() | | 正常程序执行过程中的一些事件的触发记录 | logging.info()、logging.debug() | | 触发了一个报警事件 | warnings.warn() | | 在运行过程中触发error | Raise触发一个异常 | | 报告一个异常error但是不触发 | logging.error()、logging.exception()、logging.critcal |

2. 记录等级 | level | 使用时候 | | —- | —- | | DEBUG | 详细信息 | | INFO | 期望信息 | | WARNING | 创建logger，默认为WARNING | | ERROR | | | CRITICAL | 很严重 |

3. 日记记录格式化字符串 | %(asctime)s | 易读的时间格式： 默认情况下是’2003-07-08 16：49：45,896’的形式（逗号之后的数字是毫秒部分的时间） | | —- | —- | | %(filename)s | 路径名的文件名部分。 | | %(funcName)s | 日志调用所在的函数名 | | %(levelname)s | 消息的级别名称(‘DEBUG’, ‘INFO’, ‘WARNING’, ‘ERROR’, ‘CRITICAL’). | | %(levelno)s | 对应数字格式的日志级别 (DEBUG, INFO, WARNING, ERROR,CRITICAL). | | %(lineno)d | 发出日志记录调用的源码行号 (如果可用) | | %(module)s | 所在的模块名(如test6.py模块则记录test6) | | %(message)s | 记录的信息 | | %(name)s | 调用的logger记录器的名称 | | %(process)d | 进程ID | | %(processName)s | 进程名 | | %(thread)d | 线程ID | | %(threadName)s | 线程名 |

4. 使用basicConfig方法配置logging记录格式

   import logging
   import threading 
   FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s-%(thread)d'
   DATEFMT = '[%Y-%m-%d %H:%M:%S]'
   logging.basicConfig(level = logging.INFO,format = FORMAT,datefmt=DATEFMT)
   def add(x,y):
    logging.warning('{0} {1}'.format(threading.enumerate(),x+y))
   t = threading.Timer(1,add,args=(4,5))
   t.start()
   >>[2021-09-29 16:22:40] - root - WARNING - [<_MainThread(MainThread, started 139722640516864)>, <Timer(Thread-1, started 139722549757696)>] 9-139722549757696

• logging.basicConfig()函数是一个一次性的简单配置工具使，也就是说只有在第一次调用该函数时会起作用，后续再次调用该函数时完全不会产生任何操作的，多次调用的设置并不是累加操作。
• 日志器（Logger）是有层级关系的，上面调用的logging模块级别的函数所使用的日志器是RootLogger类的实例，其名称为’root’，它是处于日志器层级关系最顶层的日志器，且该实例是以单例模式存在的。

  logging模块日志处理流程

四大组件

组件间的关系

• 日志器（logger）需要通过处理器（handler）将日志信息输出到目标位置，如：文件、sys.stdout、网络等；
• 不同的处理器（handler）可以将日志输出到不同的位置；
• 日志器（logger）可以设置多个处理器（handler）将同一条日志记录输出到不同的位置；
• 每个处理器（handler）都可以设置自己的过滤器（filter）实现日志过滤，从而只保留感兴趣的日志；
• 每个处理器（handler）都可以设置自己的格式器（formatter）实现同一条日志以不同的格式输出到不同的地方。

日志器（logger）是入口，真正干活儿的是处理器（handler），处理器（handler）还可以通过过滤器（filter）和格式器（formatter）对要输出的日志内容做过滤和格式化等处理操作。

Logger类

Logger对象有3个任务要做：

• 向应用程序代码暴露几个方法，使应用程序可以在运行时记录日志消息；
• 基于日志严重等级（默认的过滤设施）或filter对象来决定要对哪些日志进行后续处理；
• 将日志消息传送给所有感兴趣的日志handlers。

Logger对象最常用的方法分为两类：配置方法 和 消息发送方法

1. 配置方法 | Logger.setLevel() | 设置日志器将会处理的日志消息的最低严重级别 | | —- | —- | | Logger.addHandler() | 为该logger对象添加一个handler对象 | | Logger.addFilter() | 为该logger对象添加一个filter对象 | | Logger.removeHandler() | 为该logger对象移除一个handler对象 | | Logger.removeFilter() | 为该logger对象移除一个filter对象 |

2. logger对象配置完成后，可以使用下面的方法来创建日志记录 | Logger.debug(),Logger.info()… | 创建一个与它们的方法名对应等级的日志记录 | | —- | —- | | Logger.exception() | 创建一个类似于Logger.error()的日志消息 | | Logger.log() | 需要获取一个明确的日志level参数来创建一个日志记录 |

怎样得到一个Logger对象呢？一种方式是通过Logger类的实例化方法创建一个Logger类的实例，但是我们通常都是用第二种方式—logging.getLogger()方法。
logging.getLogger()方法有一个可选参数name，该参数表示将要返回的日志器的名称标识，如果不提供该参数，则其值为’root’。若以相同的name参数值多次调用getLogger()方法，将会返回指向同一个logger对象的引用。
关于logger的层级结构与有效等级的说明：

• logger的名称是一个以’.’分割的层级结构，每个’.’后面的logger都是’.’前面的logger的children，例如，有一个名称为 foo 的logger，其它名称分别为 foo.bar, foo.bar.baz 和 foo.bam都是 foo 的后代。
• logger有一个”有效等级（effective level）”的概念。如果一个logger上没有被明确设置一个level，那么该logger就是使用它parent的level;如果它的parent也没有明确设置level则继续向上查找parent的parent的有效level，依次类推，直到找到个一个明确设置了level的祖先为止。需要说明的是，root logger总是会有一个明确的level设置（默认为 WARNING）。当决定是否去处理一个已发生的事件时，logger的有效等级将会被用来决定是否将该事件传递给该logger的handlers进行处理。
• child loggers在完成对日志消息的处理后，默认会将日志消息传递给与它们的祖先loggers相关的handlers。因此，我们不必为一个应用程序中所使用的所有loggers定义和配置handlers，只需要为一个顶层的logger配置handlers，然后按照需要创建child loggers就可足够了。我们也可以通过将一个logger的propagate属性设置为False来关闭这种传递机制。

  Handler类

Handler对象的作用是（基于日志消息的level）将消息分发到handler指定的位置（文件、网络、邮件等）。Logger对象可以通过addHandler()方法为自己添加0个或者更多个handler对象。比如，一个应用程序可能想要实现以下几个日志需求：

• 把所有日志都发送到一个日志文件中；
• 把所有严重级别大于等于error的日志发送到stdout（标准输出）；
• 把所有严重级别为critical的日志发送到一个email邮件地址。

这种场景就需要3个不同的handlers，每个handler复杂发送一个特定严重级别的日志到一个特定的位置

1. 配置方法： | rf_handler.setLevel() | 设置handler将会处理的日志消息的最低严重级别 | | —- | —- | | rf_handler.setFormatter() | 为handler设置一个格式器对象 | | rf_handler.addFilter() | 为handler添加一个过滤器对象 | | rf_handler.removeFilter() | 为handler删除一个过滤器对象 |

2. 常用的handler | logging.StreamHandler | 将日志消息发送到输出到Stream，如std.out, std.err或任何file-like对象。 | | —- | —- | | logging.FileHandler | 将日志消息发送到磁盘文件，默认情况下文件大小会无限增长 | | logging.handlers. BaseRotatingHandler | 基本的日志回滚方式 | | logging.handlers.RotatingFileHandler | 将日志消息发送到磁盘文件，并支持日志文件按大小切割 | | logging.handlers.TimedRotatingFileHandler | 将日志消息发送到磁盘文件，并支持日志文件按时间切割 | | logging.handlers.SocketHandler | 远程输出日志到TCP/IP sockets | | logging.handlers. DatagramHandler | 远程输出日志到UDP sockets | | logging.handlers.HTTPHandler | 将日志消息以GET或POST的方式发送给一个HTTP服务器 | | logging.handlers.SMTPHandler | 将日志消息发送给一个指定的email地址 | | logging.handlers.SysLogHandler | 日志输出到syslog | | logging.handlers.MemoryHandle | 日志输出到内存中的指定buffer | | logging.NullHandler | 该Handler实例会忽略error messages，通常被想使用logging的library开发者使用来避免’No handlers could be found for logger XXX’信息的出现。 |

场景一： 讲日志写入到文件

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
file_handler = logging.FileHandler("log.txt")
file_handler.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")

场景二：输出到屏幕

import logging
logger = logging.getLogger(__name__) #创建日志器
console_handler = logging.StreamHandler() #创建屏幕输出
console_handler.setLevel('INFO') #设置屏幕handlerbug输出等级
Format = '%(asctime)s-%(name)s-%(levelname)s-%(message)s'
Dateformat = '[%Y-%m-%d %H:%M:%S]'
console_format = logging.Formatter(fmt=Format,datefmt=Dateformat) #生成logging的格式器
# logging.basicConfig(level=logging.DEBUG,format=Format,datefmt=Dateformat)
console_handler.setFormatter(console_format) #确定屏幕输出格式
logger.addHandler(console_handler)  #为logger对象添加一个handler对象
logger.setLevel('INFO') #设置logger对象的bug输出等级,取优先等级高的
logger.info('start print info')
logger.debug('this is a ')
logger.error('error')
logger.warning('warn')
logger.critical('down')
>>>>
[2022-04-10 19:16:55]-__main__-INFO-start print info
[2022-04-10 19:16:55]-__main__-ERROR-error
[2022-04-10 19:16:55]-__main__-WARNING-warn
[2022-04-10 19:16:55]-__main__-CRITICAL-down

场景三：同时输入到日志和屏幕

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
file_handler = logging.FileHandler("log.txt")
file_handler.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

场景三：日志回滚

import logging
from logging.handlers import RotatingFileHandler
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
#定义一个RotatingFileHandler，最多备份3个日志文件，每个日志文件最大1K
rHandler = RotatingFileHandler("log.txt",maxBytes = 1*1024,backupCount = 3)
rHandler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
rHandler.setFormatter(formatter)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(formatter)
logger.addHandler(rHandler)
logger.addHandler(console)
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")

Formater类

Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是，应用代码可以直接实例化Formatter类。另外，如果你的应用程序需要一些特殊的处理行为，也可以实现一个Formatter的子类来完成。
Formatter类的构造方法定义如下：
logging.Formatter.init(fmt=None, datefmt=None, style=’%’)
可见，该构造方法接收3个可选参数：

• fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
• datefmt：指定日期格式字符串，如果不指定该参数则默认使用”%Y-%m-%d %H:%M:%S”
• style：Python 3.2新增的参数，可取值为 ‘%’, ‘{‘和 ‘$’，如果不指定该参数则默认使用’%’

  Filter类

Filter可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能。Filter是一个过滤器基类，它只允许某个logger层级下的日志事件通过过滤。该类定义如下：
比如，一个filter实例化时传递的name参数值为’A.B’，那么该filter实例将只允许名称为类似如下规则的loggers产生的日志记录通过过滤：’A.B’，’A.B,C’，’A.B.C.D’，’A.B.D’，而名称为’A.BB’, ‘B.A.B’的loggers产生的日志则会被过滤掉。如果name的值为空字符串，则允许所有的日志事件通过过滤。
filter方法用于具体控制传递的record记录是否能通过过滤，如果该方法返回值为0表示不能通过过滤，返回值为非0表示可以通过过滤。

说明：

• 如果有需要，也可以在filter(record)方法内部改变该record，比如添加、删除或修改一些属性。
• 我们还可以通过filter做一些统计工作，比如可以计算下被一个特殊的logger或handler所处理的record数量等。

  代码实现

  ```python import logging import logging.handlers import datetime logger = logging.getLogger(‘mylogger’) logger.setLevel(logging.DEBUG) rf_handler = logging.handlers.TimedRotatingFileHandler(‘all.log’,when=’midnight’,interval=1,backupCount=7,atTime=datetime.time(0,0,0)) rf_handler.setFormatter(logging.Formatter(“%(asctime)s-%(levelname)s-%(message)s”)) f_handler = logging.FileHandler(‘error.log’) f_handler.setLevel(logging.ERROR) f_handler.setFormatter(logging.Formatter(“%(asctime)s - %(levelname)s - %(filename)s[:%(lineno)d] - %(message)s”)) logger.addHandler(rf_handler) logger.addHandler(f_handler)

logger.debug(‘debug message’) logger.info(‘info message’) logger.warning(‘warning message’) logger.error(‘error message’) logger.critical(‘critical message’)

<a name="Aumnl"></a>
# 配置方式
---
<a name="IpXMV"></a>
## 使用字典配置信息和dictConfig()函数实现日志配置
用字典来保存logging配置信息。这相对于上面所讲的基于配置文件来保存logging配置信息的方式来说，功能更加强大，也更加灵活，因为我们可把很多的数据转换成字典。比如，我们可以使用JSON格式的配置文件、YAML格式的配置文件，然后将它们填充到一个配置字典中；或者，我们也可以用Python代码构建这个配置字典，或者通过socket接收pickled序列化后的配置信息。总之，你可以使用你的应用程序可以操作的任何方法来构建这个配置字典。
```python
import logging
import logging.config
import yaml
with open('logging.yaml','r') as f_conf:
    dict_conf = yaml.load(f_conf)
logging.config.dictConfig(dict_conf)
logger = logging.getLogger('simpleExample')
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

• 配置字典说明：

可以先创建一个名额为“simple”的格式器formatter；然后创建一个名为“console”的处理器handler，并指定该handler输出日志所使用的格式器为”simple”；然后再创建一个日志器logger，并指定它所使用的处理器为”console”。
传递给dictConfig()函数的字典对象只能包含下面这些keys，其中version是必须指定的key，其它key都是可选项：

version: 1
disable_existing_loggers: False
formatters:
    simple:
      format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
handlers:
    console:
      class: logging.StreamHandler
    level: DEBUG
    formatter: simple
    stream: ext://sys.stdout
    info_file_handler:
      class: logging.handlers.RotatingFileHandler
    level: INFO
    formatter: simple
    filename: info.log
    encoding: utf8
    backupCount: 20
    error_file_handler:
      class: logging.handlers.RotatingFileHandler
    level: ERROR
    formatter: simple
    filename: error.log
    backupCount: 20
    encoding: utf8
loggers:
    simpleExample:
      level: DEBUG
    handlers: [console]
    propagate: yes
root:
    level: DEBUG
  handlers: [console_err]