python之logging模块详解_python logging模块详解

python之 logging 模块

一、日志关概念

日志是一种可以追踪某些软件运行时所发生事件的方法。软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情。一个事件可以用一个可包含可选变量数据的消息来描述。此外，事件也有重要性的概念，这个重要性也可以被称为严重性级别（level）。

日志的作用

通过log的分析，可以方便用户了解系统或软件、应用的运行情况；如果你的应用log足够丰富，也可以分析以往用户的操作行为、类型喜好、地域分布或其他更多信息；如果一个应用的log同时也分了多个级别，那么可以很轻易地分析得到该应用的健康状况，及时发现问题并快速定位、解决问题，补救损失。

简单来讲就是，我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常，也可以在应用程序出现故障时快速定位问题。比如，做运维的同学，在接收到报警或各种问题反馈后，进行问题排查时通常都会先去看各种日志，大部分问题都可以在日志中找到答案。再比如，做开发的同学，可以通过IDE控制台上输出的各种日志进行程序调试。对于运维老司机或者有经验的开发人员，可以快速的通过日志定位到问题的根源。可见，日志的重要性不可小觑。日志的作用可以简单总结为以下3点：

• 程序调试
• 了解软件程序运行情况，是否正常
• 软件程序运行故障分析与问题定位

如果应用的日志信息足够详细和丰富，还可以用来做用户行为分析，如：分析用户的操作行为、类型洗好、地域分布以及其它更多的信息，由此可以实现改进业务、提高商业利益。

日志的等级

我们先来思考下下面的两个问题：

• 作为开发人员，在开发一个应用程序时需要什么日志信息？在应用程序正式上线后需要什么日志信息？
• 作为应用运维人员，在部署开发环境时需要什么日志信息？在部署生产环境时需要什么日志信息？

在软件开发阶段或部署开发环境时，为了尽可能详细的查看应用程序的运行状态来保证上线后的稳定性，我们可能需要把该应用程序所有的运行日志全部记录下来进行分析，这是非常耗费机器性能的。当应用程序正式发布或在生产环境部署应用程序时，我们通常只需要记录应用程序的异常信息、错误信息等，这样既可以减小服务器的I/O压力，也可以避免我们在排查故障时被淹没在日志的海洋里。那么，怎样才能在不改动应用程序代码的情况下实现在不同的环境记录不同详细程度的日志呢？这就是日志等级的作用了，我们通过配置文件指定我们需要的日志等级就可以了。

不同的应用程序所定义的日志等级可能会有所差别，分的详细点的会包含以下几个等级：

• DEBUG
• INFO
• NOTICE
• WARNING
• ERROR
• CRITICAL
• ALERT
• EMERGENCY

3、日志字段信息与日志格式

一条日志信息对应的是一个事件的发生，而一个事件通常需要包括以下几个内容：

• 事件发生时间
• 事件发生位置
• 事件的严重程度–日志级别
• 事件内容

上面这些都是一条日志记录中可能包含的字段信息，当然还可以包括一些其他信息，如进程ID、进程名称、线程ID、线程名称等。日志格式就是用来定义一条日志记录中包含那些字段的，且日志格式通常都是可以自定义的。

4、日志功能的实现

几乎所有开发语言都会内置日志相关功能，或者会有比较优秀的第三方库来提供日志操作功能，比如：log4j，log4php等。它们功能强大、使用简单。Python自身也提供了一个用于记录日志的标准库模块–logging。

二、 logging 模块介绍

什么是logging模块

• logging模块是python自带的标准模块

logging模块的作用

• 主要用于输出运行日志
• 可以控制输出日志的等级, 过滤一些重要信息, 不显示大量无关要紧的调试信息
• 日志保存的路径, 可以是输出到终端, 也可以是输出到文件
• 以及文件轮转等等, 日志文件轮转指的是设置保存日志文件个数, 当超过最大日志文件个数, 最早的那个日志文件会被删除

logging模块的优点：

logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：

• 可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
• print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging则可以由开发者决定将信息输出到什么地方，以及怎么输出。

logging模块日志的级别

logging模块默认定义了以下几个日志等级，它允许开发人员自定义其他日志级别，但是这是不被推荐的，尤其是在开发供别人使用的库时，因为这会导致日志级别的混乱。

CRITICAL = 50 #FATAL = CRITICAL # 紧急
ERROR = 40	# 错误
WARNING = 30 #WARN = WARNING 	# 警告
INFO = 20	# 消息
DEBUG = 10  # 调试
NOTSET = 0  # 不设置
1
2
3
4
5
6

开发应用程序或部署开发环境时，可以使用DEBUG或INFO级别的日志获取尽可能详细的日志信息来进行开发或部署调试；

应用上线或部署生产环境时，应该使用WARNING或ERROR或CRITICAL级别的日志来降低机器的I/O压力和提高获取错误日志信息的效率。日志级别的指定通常都是在应用程序的配置文件中进行指定的。

说明：

• 上面列表中的日志等级是从上到下依次升高的，即：DEBUG < INFO < WARNING < ERROR < CRITICAL，而日志的信息量是依次减少的；
• 当为某个应用程序指定一个日志级别后，应用程序会记录所有日志级别大于或等于指定日志级别的日志信息，而不是仅仅记录指定级别的日志信息，nginx、php等应用程序以及这里的python的logging模块都是这样的。同样，logging模块也可以指定日志记录器的日志级别，只有级别大于或等于该指定日志级别的日志记录才会被输出，小于该等级的日志记录将会被丢弃。

三、logging 模块的使用方式介绍

logging使用方式介绍：

logging模块提供了两种记录日志的方式：

• 第一种方式是使用logging提供的模块级别的函数
• 第二种方式是使用Logging日志系统的四大组件

其实，logging所提供的模块级别的日志记录函数也是对logging日志系统相关类的封装而已。

示例：直接导入logging模块

import logging

# 先进行日志的基本配置
logging.basicConfig(
            # filename='access.log',          # 日志名字 (不指定默认输出到终端)
            format='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s', # 日志格式
            datefmt='%Y-%m-%d %H:%M:%S %p',   # 时间格式
            level=30,                         # 日志等级
            )

# 进行日志输出
logging.debug('在大楼使用电子设备')          # 10  调试信息
logging.info('大楼里面使用打火机')           # 20  正常运行信息
logging.warning('大楼里抽烟')               # 30 警告  可能出错
logging.error('正在大楼里玩火')             # 40 出错
logging.critical('拿着手榴弹在大楼里溜达')   # 50 出错长时间不管会崩溃
''' 输出结果
2020-12-11 19:50:30 PM - root - WARNING - test: 大楼里抽烟
2020-12-11 19:50:30 PM - root - ERROR - test: 正在大楼里玩火
2020-12-11 19:50:30 PM - root - CRITICAL - test: 拿着手榴弹在大楼里溜达
'''
# 通过日志等级过滤掉了"debug"以及"info"的日志信息 (大于以及等于你设置的那个等级才会输出)

#注意: 打开文件会发生乱码问题，它的内部运行原理可以理解为就是使用with open()打开文件且默认没有指定字符编码, 默认使用的是操作系统的GBK字符编码写入硬盘, 这个时候我们用文本编辑器打开"access.log"文件我们要使用GBK编码的方式来读。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

logging模块定义的模块级别的常用函数

其中logging.basicConfig(**kwargs)函数用于指定“要记录的日志级别”、“日志格式”、“日志输出位置”、“日志文件的打开模式”等信息，其他几个都是用于记录各个级别日志的函数。

第一种使用方式：简单配置

import logging
logging.debug("debug_msg")
logging.info("info_msg")
logging.warning("warning_msg")
logging.error("error_msg")
logging.critical("critical_msg")

'''输出结果
WARNING:root:warning_msg
ERROR:root:error_msg
CRITICAL:root:critical_msg
'''
1
2
3
4
5
6
7
8
9
10
11
12

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG）

默认输出格式为

  默认的日志格式为日志级别：Logger名称：用户输出消息
1

默认日志级别为warning，默认打印到终端

import logging

logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''
1
2
3
4
5
6
7
8
9
10
11
12
13

这里可以用 logging.basicConfig()函数调整日志级别、输出格式等

简单示例：

import logging
logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s %(name)s %(levelname)s %(message)s",
                    datefmt = '%Y-%m-%d  %H:%M:%S %a'    #注意月份和天数不要搞乱了，这里的格式化符与time模块相同
                    )
logging.debug("msg1")
logging.info("msg2")
logging.warning("msg3")
logging.error("msg4")
logging.critical("msg5")

'''输出内容
2020-12-13  23:24:21 Sun root DEBUG msg1
2020-12-13  23:24:21 Sun root INFO msg2
2020-12-13  23:24:21 Sun root WARNING msg3
2020-12-13  23:24:21 Sun root ERROR msg4
2020-12-13  23:24:21 Sun root CRITICAL msg5
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

logging.basicConfig()函数包含参数说明

logging模块中定义好的可以用于format格式字符串说明

升级版日志示例：

import logging
LOG_FORMAT = "%(asctime)s %(name)s %(levelname)s %(pathname)s %(message)s "#配置输出日志格式
DATE_FORMAT = '%Y-%m-%d  %H:%M:%S %a ' #配置输出时间的格式，注意月份和天数不要搞乱了
logging.basicConfig(level=logging.DEBUG,
                    format=LOG_FORMAT,
                    datefmt = DATE_FORMAT ,
                    filename=r"F:\python_16\day 11\test.log" #有了filename参数就不会直接输出显示到控制台，而是直接写入文件
                    )
logging.debug("msg1")
logging.info("msg2")
logging.warning("msg3")
logging.error("msg4")
logging.critical("msg5")

'''输出结果

2020-12-13  23:35:22 Sun  root DEBUG F:/python_16/day 11/stupid kid.py msg1 
2020-12-13  23:35:22 Sun  root INFO F:/python_16/day 11/stupid kid.py msg2 
2020-12-13  23:35:22 Sun  root WARNING F:/python_16/day 11/stupid kid.py msg3 
2020-12-13  23:35:22 Sun  root ERROR F:/python_16/day 11/stupid kid.py msg4 
2020-12-13  23:35:22 Sun  root CRITICAL F:/python_16/day 11/stupid kid.py msg5 

'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

说明：

• logging.basicConfig()函数是一个一次性的简单配置工具使，也就是说只有在第一次调用该函数时会起作用，后续再次调用该函数时完全不会产生任何操作的，多次调用的设置并不是累加操作。

• 日志器（Logger）是有层级关系的，上面调用的logging模块级别的函数所使用的日志器是RootLogger类的实例，其名称为’root’，它是处于日志器层级关系最顶层的日志器，且该实例是以单例模式存在的。

• 如果要记录的日志中包含变量数据，可使用一个格式字符串作为这个事件的描述消息（logging.debug、logging.info等函数的第一个参数），然后将变量数据作为第二个参数*args的值进行传递，

  如：

  logging.warning('%s is %d years old.', 'Tom', 10)，
  
  '''输出内容
  WARNING:root:Tom is 10 years old.
  '''
  1
  2
  3
  4
  5

  logging.debug(), logging.info()等方法的定义中，除了msg和args参数外，还有一个**kwargs参数。它们支持3个关键字参数: exc_info, stack_info, extra，下面对这几个关键字参数作个说明。关于exc_info, stack_info, extra关键词参数的说明：见参考资料（了解）戳我

四、日志处理流程（第二种日志使用方式）

上面简单配置的方法例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数。

第二种是一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）。logging模块就是通过这些组件来完成日志处理的，上面所使用的logging模块级别的函数也是通过这些组件对应的类来实现的。

logging模块的四种对象与组件

1.logger :（日志器）

• 作用： 负责生产日志，提供应用程序代码直接使用的接口

logger1 = logging.getLogger('[日志名]')
1

2.fitter : (过滤器)

• 作用：主要是过滤日志（不常用）

玉炉香  红蜡泪  偏照画堂秋思
1

3.handler : （处理器）

• 作用：用于将日志记录发送到指定的目的位置，控制日志输出的位置 (文件or终端)

fh1 = logging.FileHandler(filename='a1.log', encoding='utf-8')  # 文件a1
fh2 = logging.FileHandler(filename='a2.log', encoding='utf-8')  # 文件a2
sh = logging.StreamHandler()  # 终端
1
2
3

4.formatter : （格式器）

• 作用：控制日志的格式，决定日志记录的最终输出格式

formatter1 = logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(massage)s',  # 日志输出格式
    datefmt='%Y-%m-%d %H:%M:%S %p',  # 时间格式
)
1
2
3
4

说明： logging模块提供的模块级别的那些函数实际上也是通过这几个组件的相关实现类来记录日志的，只是在创建这些类的实例时设置了一些默认值。

这些组件之间的关系描述：

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

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

logging日志模块相关类及其常用方法介绍

与logging四大组件相关的类：Logger, Handler, Filter, Formatter。

Logger类

Logger对象有3个任务要做：

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

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

最常用的配置方法如下：

logger对象配置完成后，可以使用下面的方法来创建日志记录：

一个Logger对象呢？一种方式是通过Logger类的实例化方法创建一个Logger类的实例，但是我们通常都是用第二种方式–logging.getLogger()方法。

logging.getLogger()方法有一个可选参数name，该参数表示将要返回的日志器的名称标识，如果不提供该参数，则其值为’root’。若以相同的name参数值多次调用getLogger()方法，将会返回指向同一个logger对象的引用。

多次使用注意不能创建多个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对象。比如，一个应用程序可能想要实现以下几个日志需求：

• 1）把所有日志都发送到一个日志文件中；
• 2）把所有严重级别大于等于error的日志发送到stdout（标准输出）；
• 3）把所有严重级别为critical的日志发送到一个email邮件地址。这种场景就需要3个不同的handlers，每个handler复杂发送一个特定严重级别的日志到一个特定的位置。

  Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
  Handler.setFormatter()：给这个handler选择一个格式
  Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象
1
2
3

需要说明的是，应用程序代码不应该直接实例化和使用Handler实例。因为Handler是一个基类，它只定义了素有handlers都应该有的接口，同时提供了一些子类可以直接使用或覆盖的默认行为。下面是一些常用的Handler：

Formater类

Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是，应用代码可以直接实例化Formatter类。另外，如果你的应用程序需要一些特殊的处理行为，也可以实现一个Formatter的子类来完成。

Formatter类的构造方法定义如下：

logging.Formatter.__init__(fmt``=``None``, datefmt``=``None``, style``=``'%'``)
1

可见，该构造方法接收3个可选参数：

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

一般直接用logging.Formatter（fmt, datefmt）

Filter类（暂时了解）

Filter可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能。Filter是一个过滤器基类，它只允许某个logger层级下的日志事件通过过滤。该类定义如下：

  class logging.Filter(name='')
      filter(record)
1
2

比如，一个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数量等。

logging日志流处理流程

下面这个图描述了日志流的处理流程：

我们来描述下上面这个图的日志流处理流程：

• 1）（在用户代码中进行）日志记录函数调用，如：logger.info(…)，logger.debug(…)等；
• 2）判断要记录的日志级别是否满足日志器设置的级别要求（要记录的日志级别要大于或等于日志器设置的级别才算满足要求），如果不满足则该日志记录会被丢弃并终止后续的操作，如果满足则继续下一步操作；
• 3）根据日志记录函数调用时掺入的参数，创建一个日志记录（LogRecord类）对象；
• 4）判断日志记录器上设置的过滤器是否拒绝这条日志记录，如果日志记录器上的某个过滤器拒绝，则该日志记录会被丢弃并终止后续的操作，如果日志记录器上设置的过滤器不拒绝这条日志记录或者日志记录器上没有设置过滤器则继续下一步操作–将日志记录分别交给该日志器上添加的各个处理器；
• 5）判断要记录的日志级别是否满足处理器设置的级别要求（要记录的日志级别要大于或等于该处理器设置的日志级别才算满足要求），如果不满足记录将会被该处理器丢弃并终止后续的操作，如果满足则继续下一步操作；
• 6）判断该处理器上设置的过滤器是否拒绝这条日志记录，如果该处理器上的某个过滤器拒绝，则该日志记录会被当前处理器丢弃并终止后续的操作，如果当前处理器上设置的过滤器不拒绝这条日志记录或当前处理器上没有设置过滤器测继续下一步操作；
• 7）如果能到这一步，说明这条日志记录经过了层层关卡允许被输出了，此时当前处理器会根据自身被设置的格式器（如果没有设置则使用默认格式）将这条日志记录进行格式化，最后将格式化后的结果输出到指定位置（文件、网络、类文件的Stream等）；
• 8）如果日志器被设置了多个处理器的话，上面的第5-8步会执行多次；
• 9）这里才是完整流程的最后一步：判断该日志器输出的日志消息是否需要传递给上一级logger（之前提到过，日志器是有层级关系的）的处理器，如果propagate属性值为1则表示日志消息将会被输出到处理器指定的位置，同时还会被传递给parent日志器的handlers进行处理直到当前日志器的propagate属性为0停止，如果propagate值为0则表示不向parent日志器的handlers传递该消息，到此结束。

可见，一条日志信息要想被最终输出需要依次经过以下几次过滤：

• 日志器等级过滤；
• 日志器的过滤器过滤；
• 日志器的处理器等级过滤；
• 日志器的处理器的过滤器过滤；

需要说明的是： 关于上面第9个步骤，如果propagate值为1，那么日志消息会直接传递交给上一级logger的handlers进行处理，此时上一级logger的日志等级并不会对该日志消息进行等级过滤。

日志流处理简要流程

1、创建一个logger

2、设置下logger的日志的等级

3、创建合适的Handler(FileHandler要有路径)

4、设置下每个Handler的日志等级

5、创建下日志的格式

6、向Handler中添加上面创建的格式

7、将上面创建的Handler添加到logger中

8、打印输出logger.debug\logger.info\logger.warning\logger.error\logger.critical

示例

import logging
​
#创建logger，如果参数为空则返回root logger
logger = logging.getLogger("nick")
logger.setLevel(logging.DEBUG)  #设置logger日志等级
​
#创建handler
fh = logging.FileHandler("test.log",encoding="utf-8")
ch = logging.StreamHandler()
​
#设置输出日志格式
formatter = logging.Formatter(
    fmt="%(asctime)s %(name)s %(filename)s %(message)s",
    datefmt="%Y/%m/%d %X"
    )
​
#注意 logging.Formatter的大小写
 
#为handler指定输出格式，注意大小写
fh.setFormatter(formatter)
ch.setFormatter(formatter)
​
#为logger添加的日志处理器
logger.addHandler(fh)
logger.addHandler(ch)
​
#输出不同级别的log
logger.warning("泰拳警告")
logger.info("提示")
logger.error("错误")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

五、配置logging的几种方式

---

作为开发者，我们可以通过以下3中方式来配置logging:

• 1）使用Python代码显式的创建loggers, handlers和formatters并分别调用它们的配置函数；
• 2）创建一个日志配置文件，然后使用fileConfig()函数来读取该文件的内容；
• 3）创建一个包含配置信息的dict，然后把它传递个dictConfig()函数；

日志字典配置

# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
"""
%(name)s             Logger的名字, 没有指定默认就是root
%(levelno)s          数字形式的日志级别(10, 20, 30, 40, 50)
%(levelname)s        文本形式的日志级别(debug调试, info信息, warning警告, error错误, critical危险)
%(pathname)s         调用日志输出函数的模块的完整路径名，可能没有
%(filename)s         调用日志输出函数的模块的文件名
%(module)s           调用日志输出函数的模块名
%(funcName)s         调用日志输出函数的函数名
%(lineno)d           调用日志输出函数的语句所在的代码行
%(created)f          当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d  输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s          字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d           线程ID。可能没有
%(threadName)s       线程名。可能没有
%(process)d          进程ID。可能没有
%(message)s          用户输出的消息
"""

# 2. 定义日志的输出格式: 强调!! 其中的%(name)s为调用logging模块后, 使用logging.getlogger()时指定的日志名
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

# 3、日志配置字典
LOGGING_DIC = {
    # version 指定的是你的版本信息。
    'version': 1,

    # disable_existing_loggers 关闭已存在日志。默认False
    'disable_existing_loggers': False,

    # formatters 加s代表可以设置很多个不同的日志格式。(注意: 这个不能改，这个是固定的。)
    'formatters': {

        # standard, simple, test 主要目的是通过自定义这些名字让"handlers"中拿到下面自定义的日志格式的表现形式(提示: 自定义的日志格式命名可以修改)。
        'standard': {
            # format (注意: 这个不能改，这是固定的格式。)  # standard_format 这里可以指定你自定义的日志格式表现的形式。这里是一个变量, 代指的就是步骤2中定义的日志的输出格式.
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'test': {
            'format': test_format
        },
    },
    'filters': {},

    # handlers 它是日志的接收者, 它用于控制日志的输出位置。不同的handler可以将日志输出到不同的位置.
    'handlers': {
        # console, default, other 这是你自定义的handler名(注意: 这里可以修改, 是你自定义的名字)

        # 输出位置: 打印到终端的日志, 由下面的class对应的logging.StreamHandler控制
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # class 指定日志输出的形式。(注意不能改。)打印到屏幕
            'formatter': 'simple'  # formatter 指定日志格式输出的形式, 会跑到上面formatters找到你之前所定义的格式simple。
        },

        # 输出位置: 打印到文件的日志, 由下面的class对应的logging.handlers.RotatingFileHandler控制
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',    # RotatingFileHandler 指定日志轮转, 由下面的maxBytes与backupCount互相组合使用, 防止日志文件内容过大, 读取困难(补充: 内部的底层原理就是当达到了轮转的要求, 就会把你指定的文件"a1.log"重命名, 再新建一个"a1.log"文件, 存放最新的日志内容.)。 # 日志轮转,的重要的意义在于当你的日志文件存储数据过大取的情况。不应该让你的日志在日志文件里不断的累加。如果你的日志文件过大几的话，你打开文件的话就会非常的慢。所以我们需要定期的分割。
            
            'formatter': 'standard',
            'filename': 'a1.log',
            # maxBytes 最大轮转值, 当达到了这个值, 日志文件就会轮转.默认单位是字节Bytes。这里计算出来是: 5M
            'maxBytes': 1024 * 1024 * 5,
            'backupCount': 5,  # backupCount 指的是最多给你保存几份, 当达到了保存限制, 会删除你最老的日志文件。
            'encoding': 'utf-8',  # 指定日志文件写入硬盘的编码.
        },

        # 输出位置: 你指定的文件"a2.log", 由下面的class对应的logging.FileHandler控制
        'other': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # FileHandler 指定日志输出的形式。输出到文件中。
            'formatter': 'test',
            'filename': 'a2.log',  # filename 既然要输出到文件中，那必须要指定文件路径，如果是在项目中，我们需要使用os.path等规范化路径。
            'encoding': 'utf-8',  # encoding 这里指定指定日志文件写入硬盘的编码.
        },
    },

    # loggers 它是日志的产生者, 负责产生不同级别的日志, 产生的日志会传递给上面的handlers中, 让handlers中的每个自定义的"handler"控制输出的位置。
    'loggers': {
        # logger
        # "logger"  指定''这种形式, 在执行logging.getLogger(key)时会判断,如果指定的key在下面的这些"logger"中都没找到, 就会把自定义key交给''中的"logger"处理, 处理以后, 交给上面的handlers进行处理
        '': {
            'handlers': ['default', 'console'],
            # handlers 这里指定你要交给的Handler路径, 交给"default"和"console"上面我们"handlers"中自定义的"handler"处理.
            'level': 'DEBUG',  # 这里又设置了日志级别，而handler中又设置了日志级别，这里有两层关卡。当使用logger_obj.info()这样的功能输入内容的时候. 会进行判断。如果日志级别满足，那么就会被收取到。满足以后会交给handlers中你自定义的"handler"来进行第二次筛选, 如果又满足，那么就会被你相应的"handler"功能, 进行处理。loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会将日志向上层层传递
        },

        # 这里为你专门的日志名进行提供服务, 在使用loggin.getlogger("日志名")时, 会跑到这里来匹配, 如果当时你指定的"日志名"与下面的key一致的时候就用使用下面的处理方式, 处理当前的日志. 当然没有匹配的情况下会跑到上面你什么都没指定''的里面去, 处理当前的日志, 以你指定的日志名作为你的日志名.
        '专门的采集': {
            'handlers': ['other', ],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

六、参考文献

• https://www.cnblogs.com/yyds/p/6901864.html
• https://docs.python.org/3.5/howto/logging.html
• https://docs.python.org/3.5/library/logging.config.html
• https://docs.python.org/3.5/howto/logging-cookbook.html
• https://blog.csdn.net/huilan_same/article/details/51858817
• https://www.cnblogs.com/Nicholas0707/p/9021672.html#_label1_1