Python中logging模块的整体理解

这是个啥&＃xff1a;

• logging就是用来在程序代码的执行过程中做记录的。

一. logging的初步理解

logging的主入口只有一个&＃xff0c;那就是日志处理的主对象。至于要输送记录内容到哪里、怎么组织记录这些内容、怎么过滤这些问题本质上都是属于数据进入主入口之后的对输入内容的个性化加工处理方式&＃xff0c;而这些处理方式都是通过addHandler添加进去&＃xff0c;logging中包含的handler主要有如下几种&＃xff1a;

handler名称&＃xff1a;位置&＃xff1b;作用StreamHandler&＃xff1a;logging.StreamHandler&＃xff1b;日志输出到流&＃xff0c;可以是sys.stderr&＃xff0c;sys.stdout或者文件
FileHandler&＃xff1a;logging.FileHandler&＃xff1b;日志输出到文件
BaseRotatingHandler&＃xff1a;logging.handlers.BaseRotatingHandler&＃xff1b;基本的日志回滚方式
RotatingHandler&＃xff1a;logging.handlers.RotatingHandler&＃xff1b;日志回滚方式&＃xff0c;支持日志文件最大数量和日志文件回滚
TimeRotatingHandler&＃xff1a;logging.handlers.TimeRotatingHandler&＃xff1b;日志回滚方式&＃xff0c;在一定时间区域内回滚日志文件
SocketHandler&＃xff1a;logging.handlers.SocketHandler&＃xff1b;远程输出日志到TCP/IP sockets
DatagramHandler&＃xff1a;logging.handlers.DatagramHandler&＃xff1b;远程输出日志到UDP sockets
SMTPHandler&＃xff1a;logging.handlers.SMTPHandler&＃xff1b;远程输出日志到邮件地址
SysLogHandler&＃xff1a;logging.handlers.SysLogHandler&＃xff1b;日志输出到syslog
NTEventLogHandler&＃xff1a;logging.handlers.NTEventLogHandler&＃xff1b;远程输出日志到Windows NT/2000/XP的事件日志
MemoryHandler&＃xff1a;logging.handlers.MemoryHandler&＃xff1b;日志输出到内存中的指定buffer
HTTPHandler&＃xff1a;logging.handlers.HTTPHandler&＃xff1b;通过"GET"或者"POST"远程输出到HTTP服务器


作为初学者&＃xff0c;我们能理解StreamHandler、FileHandler、RotatingHandler这三个处理器(handler)(就可以快速上道了。

• StreamHandler&＃xff1a;其实是把输入到主入口的内容&＃xff0c;经过某种组织方式&＃xff0c;将日志输出到特定的位置&＃xff0c;默认是输出到标准输出sys.stderr&＃xff1b;
• FileHandler&＃xff1a;这个就比较明确了&＃xff0c;经过设定的处理&＃xff0c;把日志输出到文件中&＃xff0c;所以起码是要求我们输入文件名filename&＃xff1b;
• RotatingHandler&＃xff1a;这个其实是FileHandler的扩展板&＃xff0c;能够设定日志回滚方式&＃xff0c;支持日志文件最大数量和日志文件回滚&＃xff0c;接下来举例说明。

接下来通过代码理解

import logging
from logging.handlers import RotatingFileHandler # 导入上面介绍的“日志回滚方式”处理器&＃xff0c;我们那这个作为例子# 通过__name__就可以看出当前文件是不是程序的入口文件&＃xff0c;如果__name__!&＃61;__main__,就说明当前文件是被其他文件的代码所调用的模块&＃xff0c;
# 此时__name__就是该模块的模块名
# 通过logging.getLogger()就是在实例化一个logging类&＃xff0c;传进去的name参数就是实例名&＃xff0c;可以通过 %(name)s 的方式在Formatter里面
# 设定输出格式
logger &＃61; logging.getLogger(&＃39;__name__&＃39;) # 设定级别&＃xff0c;由低到高分别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL
# 本质上是一种过滤方式&＃xff0c;设定的level决定了哪些内容可以被记录&＃xff0c;哪些不能被记录。
# 其实setlevel是这个方法不仅主对象logger拥有&＃xff0c;后面的处理器handler也有自己的setlevel方法&＃xff0c;都是一样的方法&＃xff0c;每一个handler
# 都可以利用setlevel设定自己的日志记录level
logger.setLevel(level &＃61; logging.INFO)# 定义一个RotatingFileHandler&＃xff0c;最多备份3个日志文件&＃xff0c;每个日志文件最大10K。默认的mode &＃61; &＃39;a&＃39;,就是append模式记录数据&＃xff0c;
# 这种方式不会覆盖掉之前的内容。
# 注意&＃xff0c;此时实例化的是handler&＃xff0c;并没有挂靠到前面实例化的logger上&＃xff0c;后面通过addHandler才可以添加到主对象上
rHandler &＃61; RotatingFileHandler("log.txt",maxBytes &＃61; 10*1024,backupCount &＃61; 3)
rHandler.setLevel(logging.INFO)
# 设定日志记录格式&＃xff0c;关于格式的各种说明后文会列出
formatter &＃61; logging.Formatter(&＃39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&＃39;)
# 把格式传递到rHandler实例处理器的setFormatter方法中
rHandler.setFormatter(formatter)
# 以上最近的4步设定几乎是模板&＃xff1a;实例化一个handler——设定日志级别——格式规定——格式设定# 同一个主对象&＃xff0c;可以添加多个handler&＃xff0c;相当于并行的几条生产线&＃xff0c;他们的输入内容一致&＃xff0c;都是来源于主对象入口。后面的工作就是分支处理
# 每个handler生产自己制定格式的日志数据。
# 下面的logging.StreamHandler()是本文添加的第二个handler&＃xff0c;没有指定stream&＃xff0c;默认就是输出到控制台(准确说是sys.stderr)
console &＃61; logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(formatter)# 当特定handler设置完毕后&＃xff0c;就要把该生产线(handler)并入添加到主对象logger上&＃xff0c;利用的是主对象的addHandler方法
logger.addHandler(rHandler)
logger.addHandler(console)# 接下来就是从主对象的入口输入内容&＃xff0c;这些内容会经过主对象的并行的生产线handler&＃xff0c;输出每条生产线所对应格式的日志内容到该条生产线的
# 指定输出地。
# logger.info、logger.warning都是在告诉记录器logger该条信息的级别&＃xff0c;不然他自己是无法分辨的。
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")


控制台的输出内容如下&＃xff1a;
目录里多了一log.txt文件&＃xff1a;

如果你在jupyter notebook里再次运行这一段代码&＃xff0c;你会发现&＃xff0c;每一条日志内容会输出两次&＃xff0c;再运行则每一条日志内容会输出三次&＃xff0c;为什么&＃xff1f;
原来&＃xff0c;问题就在logging.getLogger()这个类上&＃xff0c;如果能从当前的全局变量(变量本质上就是对象)中找到相同name的logger&＃xff0c;则引用已经存在的logger即可&＃xff0c;如果找不到才会创建&＃xff0c;这一点从它的docstring中也可以证实&＃xff1a;

Signature: logging.getLogger(name&＃61;None)
Docstring:
Return a logger with the specified name, creating it if necessary.
看见了吧&＃xff0c;creating it if necessary

当获取到相同name的logger时&＃xff0c;由于又重复添加了handler&＃xff0c;所以生产线又多了几条&＃xff0c;相应地输出的日志信息就会增多。

当然你也可以在上面代码的末尾添加如下内容&＃xff0c;即可规避这种问题&＃xff1a;

logger.removeHandler(rHandler)# 执行完相关程序在结尾移除特定的handler
logger.removeHandler(console)


二. 深入了解细节

入门推荐篇

• 网上相关博文不少&＃xff0c;个人觉得这篇很有参考价值&＃xff1a;https://blog.csdn.net/pansaky/article/details/90710751

深入了解篇&＃xff1a;

• 如果上面链接的博文真正理解了&＃xff0c;那么接下来推荐的这篇博文将会让你更进一步&＃xff0c;篇幅不长&＃xff0c;但信息量不少&＃xff1a;https://www.jianshu.com/p/cad8a77762b3

三. 补充性说明

关于多模块的使用&＃xff0c;请参看入门推荐篇 2.5 多模块使用。
请务必先阅读2.5节的代码。

首先在主模块定义了logger&＃xff0c;name&＃61;&＃39;mainModule&＃39;&＃xff0c;并对它进行了配置&＃xff0c;就可以在解释器进程里面的其他地方通过getLogger(‘mainModule’)得到的对象都是一样的&＃xff0c;不需要重新配置&＃xff0c;可以直接使用[1]。定义的该logger的子logger&＃xff0c;都可以共享父logger的定义和配置&＃xff0c;所谓的父子logger是通过命名来识别&＃xff0c;任意以&＃39;mainModule&＃39;开头的logger都是它的子logger&＃xff0c;例如’mainModule.sub’。

• [1]处的描述和本文【一. logging的初步理解】里面蓝色字部分的描述吻合。
• 父子logger是通过命名来识别&＃xff0c;前提是在一个进程里面&＃xff0c;这很好地把logging的配置扩展到全环境&＃xff0c;极大地方便了我们的使用。

四. 捕获traceback

Python中的traceback模块被用于跟踪异常返回信息&＃xff0c;可以在logging中记录下traceback

import logging
import sys
logger &＃61; logging.getLogger(&＃39;traceback-capturing&＃39;)
logger.setLevel(level &＃61; logging.INFO)
handler &＃61; logging.FileHandler("log.txt",mode&＃61;&＃39;w&＃39;)
handler.setLevel(logging.INFO)
formatter &＃61; logging.Formatter(&＃39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&＃39;)
handler.setFormatter(formatter)console &＃61; logging.StreamHandler(stream&＃61;sys.stdout) # 这里我们指定说出到”sys.stdout“标准输出中&＃xff0c;默认是输出到”sys.stderr“,#所以下面的内容的背景是白色的&＃xff0c;否则是粉红色的背景
console.setLevel(logging.INFO)logger.addHandler(handler)
logger.addHandler(console)logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
try:open("sklearn.txt","rb")
except (SystemExit,KeyboardInterrupt):raise
except Exception:# To pass exception information, use the keyword argument exc_info with a true value, e.g.# logger.error("Houston, we have a %s", "major problem", exc_info&＃61;1)logger.error("Faild to open sklearn.txt from logger.error,that is %s"," major problem",exc_info &＃61; True)# 也可以用 logger.exceptionlogger.info("Finish")
logger.removeHandler(handler)
logger.removeHandler(console)


结果如下&＃xff1a;

五. 通过JSON文件配置logging模块

首先看看json文件的配置&＃xff0c;可以发现&＃xff0c;主要有以下几个部分&＃xff1a;

• formatters&＃xff1a;用来定义输出的格式。里面的“simple”就是其中的一种格式&＃xff0c;你还可以据此定义更多的格式&＃xff0c;和"simple"并行放在一起。
• "handlers"&＃xff1a;"handlers"的value就是众多处理器handler的集合地&＃xff0c;该案例的文件定义了"console"、"info_file_handler"、"error_file_handler"这几个处理器实例&＃xff0c;每一个实例字典里的键值对就是在配置相应的handler。其中"class"代表你选择的handler类型&＃xff08;通常是StreamHandler、FileHandler、RotatingHandler&＃xff09;
• "loggers"&＃xff1a;这里面可以定义很多记录器logger&＃xff0c;本案例我们仅添加了一个name&＃61;"my_module"的记录器logger&＃xff0c;而每个记录器下面又可以添加多个handler&＃xff0c;存放在handlers对应的value里面。propagate是什么&＃xff1f;起什么作用&＃xff1f;下一节会说。
• "root":定义的是根记录器logger&＃xff0c;name&＃61;“root”&＃xff0c;其他的类似。

{"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","maxBytes":10485760,"backupCount":20,"encoding":"utf8"},"error_file_handler":{"class":"logging.handlers.RotatingFileHandler","level":"ERROR","formatter":"simple","filename":"errors.log","maxBytes":10485760,"backupCount":20,"encoding":"utf8"}},"loggers":{"my_module":{"level":"ERROR","handlers":["info_file_handler"],"propagate":"no"}},"root":{"level":"INFO","handlers":["console","info_file_handler","error_file_handler"]}
}


当配置文件写好后&＃xff0c;就可以加载配置文件了&＃xff1a;

import json
import logging.config
import osdef setup_logging(default_path &＃61; "logging.json",default_level &＃61; logging.INFO,env_key &＃61; "LOG_CFG"):path &＃61; default_pathvalue &＃61; os.getenv(env_key,None)if value:path &＃61; valueif os.path.exists(path):with open(path,"r") as f: # 打开配置文件config &＃61; json.load(f) # 利用json模块加载配置文件到内存&＃xff0c;转换成Python的dict对象
# print(config["handlers"]["info_file_handler"])logging.config.dictConfig(config) # 配置else:logging.basicConfig(level &＃61; default_level)def func():logging.info("start func") # 通过logging.info/warning操作&＃xff0c;默认用的是name"root"的logger记录器logging.info("exec func")logging.info("end func")logger.info("start func")logger.info("exec func")logger.info("end func")if __name__ &＃61;&＃61; "__main__":setup_logging(default_path &＃61; "logging.json")logger &＃61; logging.getLogger(&＃39;my_module&＃39;) # 实例化一个已经配置好的name&＃61;"my_module"的loggerfunc()


六. propagate有什么作用?

关于这个问题&＃xff0c;在我推荐的第二篇文章里其实有涉及&＃xff0c;官方文档中提供的流程图足以说明logger的运行机制。
从官方文档中提供的流程图可以看出&＃xff0c;propagate会把当前的logger设置为其parent的logger, 并将LogRecord传入parent的Handler, 这就会导致一个有趣的现象:

# 给root logger 添加一个Handler
In [42]: import sysIn [43]: logging.basicConfig(stream&＃61;sys.stdout, level&＃61;logging.DEBUG)In [44]: logging.root.handlers
Out[44]: [<StreamHandler <stdout> (NOTSET)>]# 新建一个child loggerIn [5]: child &＃61; logging.getLogger(&＃39;child&＃39;)In [6]: child.parent
Out[6]: <RootLogger root (DEBUG)>In [7]: child.handlers
Out[7]: []# log 信息
In [8]: child.debug(&＃39;this is a debug message&＃39;)
DEBUG:child:this is a debug message


我们的child logger 是没有Handler的, 但是我们的LogRecord还是被发送到了终端, 这就是propagate的作用, 它把子代的所有LogRecord都发送给了父代, 循环往复, 最终到达root, 如果我们在子代中设置了hander, 那么一个LogRecord就会被发送两次:

In [9]: child.addHandler(logging.StreamHandler())In [10]: child.debug(&＃39;this message will be handled twice&＃39;)
this message will be handled twice
DEBUG:child:this message will be handled twice


第一次是子代发送到stderr(默认), 第二次是使用root的Handler.

讲到这里&＃xff0c;通观本篇全文&＃xff0c;你就可以发现&＃xff0c;除了name&＃61;“root”&＃xff0c;其他所有的logger都是parent logger&＃xff0c;归根结底其他logger都是root的child。这里我们可以通过logger.propagate来查看每一个记录器的propagate属性(bool值)。

下面引用的这句话是第二篇文章作者的观点&＃xff0c;我认为他说的是对的&＃xff0c;但是好像和大家的使用习惯不太一样&＃xff0c;通常我们习惯实例化一个logger&＃xff0c;并且对实例logger进行配置&＃xff0c;虽然我们可以配置logging.root来实现这位作者的观点&＃xff0c;但通常我们并不这么做。

我们没必要配置子代的Handler, 因为最终所有的LogRecord都会被转发到root, 我们只需要配置它就可以了.

再次强调&＃xff0c;第二篇文章非常有深入了解logging的价值&＃xff0c;希望看到本篇博文的读者最好去研读下。