Python 日志模块#

日志是可以追踪某些软件允许时候发生的事件的方法，通过观察日志信息可以帮助开发人员发现并处理错误

以及logging两个常用函数

• logging.log: 创建一条严重级别为level的日志记录
• logging.basicConfig: 对root logger 进行一次性配置

组件列表#

基础使用#

1
import logging
2

3
logging.debug("This is a debug log.")
4
logging.info("This is a info log.")
5
logging.warning("This is a warning log.")
6
logging.error("This is a error log.")
7
logging.critical("This is a critical log.")
8
# or
9
logging.log(logging.DEBUG, "This is a debug log.")
10
logging.log(logging.INFO, "This is a info log.")
11
logging.log(logging.WARNING, "This is a warning log.")
12
logging.log(logging.ERROR, "This is a error log.")
13
logging.log(logging.CRITICAL, "This is a critical log.")

执行结果

1
WARNING:root:This is a warning log.
2
ERROR:root:This is a error log.
3
CRITICAL:root:This is a critical log.

Q: 打印出来的日志信息中各字段表示什么意思？为什么会这样输出？

A: 上面输出结果中每行日志记录的各个字段含义分别是：日志级别:日志器名称:日志内容 。之所以会这样输出，是因为logging模块提供的日志记录函数所使用的日志器设置的日志格式默认是BASIC_FORMAT，其值为："%(levelname)s:%(name)s:%(message)s"

basicConfig 函数说明#

该方法用于为logging日志系统做一些基本配置，方法定义如下：

1
logging.basicConfig(**kwargs)

1
logging.basicConfig(level=logging.DEBUG)
2

3
logging.debug("This is a debug log.")
4
logging.info("This is a info log.")
5
logging.warning("This is a warning log.")
6
logging.error("This is a error log.")
7
logging.critical("This is a critical log.")

1
DEBUG:root:This is a debug log.
2
INFO:root:This is a info log.
3
WARNING:root:This is a warning log.
4
ERROR:root:This is a error log.
5
CRITICAL:root:This is a critical log.

1
LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
2
logging.basicConfig(filename='my.log', level=logging.DEBUG, format=LOG_FORMAT)

1
05/08/2017 14:29:04 PM - DEBUG - This is a debug log.
2
05/08/2017 14:29:04 PM - INFO - This is a info log.
3
05/08/2017 14:29:04 PM - WARNING - This is a warning log.
4
05/08/2017 14:29:04 PM - ERROR - This is a error log.
5
05/08/2017 14:29:04 PM - CRITICAL - This is a critical log.

logging 模块日志流处理流程#

在使用logging模块高级用法前，很有必要了解一些logging模块包含的重要组件和其工作流程

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

总结: 日期器(logger)是入口，真正干活的是处理器(handler)，处理器(handler)还可以通过过滤器(filter)和格式器(formatter) 对要输出的日志进行过滤和格式化等操作。

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

1
class logging.Filter(name='')
2
    filter(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传递该消息，到此结束。

日志模块实现#

现在有以下几个日志记录的需求：

1. 要求将所有级别的所有日志都写入磁盘文件中
2. all.log文件中记录所有的日志信息，日志格式为：日期和时间 - 日志级别 - 日志信息
3. error.log文件中单独记录error及以上级别的日志信息，日志格式为：日期和时间 - 日志级别 - 文件名[:行号] - 日志信息
4. 要求all.log在每天凌晨进行日志切割

分析:

1. 要记录所有级别的日志，因此日志器的有效level需要设置为最低级别—DEBUG;
2. 日志需要被发送到两个不同的目的地，因此需要为日志器设置两个handler；另外，两个目的地都是磁盘文件，因此这两个handler都是与FileHandler相关的；
3. all.log要求按照时间进行日志切割，因此他需要用logging.handlers.TimedRotatingFileHandler; 而error.log没有要求日志切割，因此可以使用FileHandler;
4. 两个日志文件的格式不同，因此需要对这两个handler分别设置格式器；

1
import logging
2
import logging.handlers
3
import datetime
4

5
logger = logging.getLogger('mylogger')
6
logger.setLevel(logging.DEBUG)
7

8
rf_handler = logging.handlers.TimedRotatingFileHandler('all.log', when='midnight', interval=1, backupCount=7, atTime=datetime.time(0, 0, 0, 0))
9
rf_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
10

11
f_handler = logging.FileHandler('error.log')
12
f_handler.setLevel(logging.ERROR)
13
f_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(filename)s[:%(lineno)d] - %(message)s"))
14

15
logger.addHandler(rf_handler)
16
logger.addHandler(f_handler)
17

18
logger.debug('debug message')
19
logger.info('info message')
20
logger.warning('warning message')
21
logger.error('error message')
22
logger.critical('critical message')

配置 logging 的几种方式#

1
# 创建一个日志器logger并设置其日志级别为DEBUG
2
logger = logging.getLogger('simple_logger')
3
logger.setLevel(logging.DEBUG)
4

5
# 创建一个流处理器handler并设置其日志级别为DEBUG
6
handler = logging.StreamHandler(sys.stdout)
7
handler.setLevel(logging.DEBUG)
8

9
# 创建一个格式器formatter并将其添加到处理器handler
10
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
11
handler.setFormatter(formatter)
12

13
# 为日志器logger添加上面创建的处理器handler
14
logger.addHandler(handler)
15

16
# 日志输出
17
logger.debug('debug message')
18
logger.info('info message')
19
logger.warn('warn message')
20
logger.error('error message')
21
logger.critical('critical message')

1
[loggers]
2
keys=root,sampleLogger
3

4
[handlers]
5
keys=consoleHandler,fileHandler
6

7
[formatters]
8
keys=simpleFormatter
9

10
[logger_root]
11
level=DEBUG
12
handlers=consoleHandler
13

14
[logger_sampleLogger]
15
level=DEBUG
16
handlers=fileHandler, consoleHandler
17
qualname=sampleLogger
18
propagate=0
19

20
[handler_consoleHandler]
21
class=StreamHandler
22
level=DEBUG
23
formatter=simpleFormatter
24
args=(sys.stdout,)
25

26
[handler_fileHandler]
27
class=FileHandler
28
level=DEBUG
29
formatter=simpleFormatter
30
args=('app.log', 'w', 'utf-8')
31

32
[formatter_simpleFormatter]
33
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
34
datefmt=%Y-%m-%d %H:%M:%S

1
import logging.config
2
# 避免出现格式解析问题
3
with open('logging.conf', 'r', encoding='utf-8') as f:
4
    logging.config.fileConfig(f)
5

6
logger = logging.getLogger('sampleLogger')
7
logger.debug('调试信息')

1
logging.config.dictConfig(config)
2
# 该函数可以从一个字典对象中获取日志配置信息，config参数就是这个字典对象。关于这个字典对象的内容规则会在下面进行描述。

1
handlers:
2
  console:
3
    class : logging.StreamHandler
4
    formatter: brief
5
    level   : INFO
6
    filters: [allow_foo]
7
    stream  : ext://sys.stdout
8
  file:
9
    class : logging.handlers.RotatingFileHandler
10
    formatter: precise
11
    filename: logconfig.log
12
    maxBytes: 1024
13
    backupCount: 3

添加上下文信息#

1. 通过传递 extra 参数 引入上下文信息

   1
   import logging
   2
   import sys
   3
   
   4
   fmt = logging.Formatter("%(asctime)s - %(name)s - %(ip)s - %(username)s - %(message)s")
   5
   h_console = logging.StreamHandler(sys.stdout)
   6
   h_console.setFormatter(fmt)
   7
   logger = logging.getLogger("myPro")
   8
   logger.setLevel(logging.DEBUG)
   9
   logger.addHandler(h_console)
   10
   
   11
   extra_dict = {"ip": "113.208.78.29", "username": "Petter"}
   12
   logger.debug("User Login!", extra=extra_dict)
   13
   
   14
   extra_dict = {"ip": "223.190.65.139", "username": "Jerry"}
   15
   logger.info("User Access!", extra=extra_dict)
   

2. 通过使用LoggerAdapters 引入上下文

   使用LoggerAdapter 类传递信息到日志事件是一个非常简单的方式，可以把它看作第一张实现方式的优化方法，因为它给extra提供了默认值。

   1
   import logging
   2
   import sys
   3
   
   4
   
   5
   # 初始化一个要传递给LoggerAdapter构造方法的logger实例
   6
   fmt = logging.Formatter("%(asctime)s - %(name)s - %(ip)s - %(username)s - %(message)s")
   7
   h_console = logging.StreamHandler(sys.stdout)
   8
   h_console.setFormatter(fmt)
   9
   init_logger = logging.getLogger("myPro")
   10
   init_logger.setLevel(logging.DEBUG)
   11
   init_logger.addHandler(h_console)
   12
   
   13
   # 初始化一个要传递给LoggerAdapter构造方法的上下文字典对象
   14
   extra_dict = {"ip": "IP", "username": "USERNAME"}
   15
   
   16
   # 获取一个LoggerAdapter类的实例
   17
   logger = logging.LoggerAdapter(init_logger, extra_dict)
   18
   
   19
   # 应用中的日志记录方法调用
   20
   logger.info("User Login!")
   21
   logger.info("User Login!", extra={"ip": "113.208.78.29", "username": "Petter"})
   22
   logger.extra = {"ip": "113.208.78.29", "username": "Petter"}
   23
   logger.info("User Login!")
   24
   logger.info("User Login!")
   

3. 通过 Filiters 引入上下文

记录日志到数据库#

1
import logging
2

3
# 创建日志记录器
4
logger = logging.getLogger(__name__)
5
logger.setLevel(logging.DEBUG)
6

7
# 创建文件处理器
8
file_handler = logging.FileHandler('app.log')
9
file_handler.setLevel(logging.DEBUG)
10

11
# 创建数据库处理器
12
import sqlite3
13
from logging.handlers import BaseRotatingHandler
14

15
class DatabaseHandler(BaseRotatingHandler):
16
    def __init__(self, filename):
17
        super().__init__(filename)
18

19
    def emit(self, record):
20
        conn = sqlite3.connect('logs.db')
21
        conn.execute('''
22
        INSERT INTO logs (level, message) VALUES (?, ?)
23
        ''', (record.levelname, record.getMessage()))
24
        conn.commit()
25
        conn.close()
26

27
database_handler = DatabaseHandler('logs.db')
28
database_handler.setLevel(logging.DEBUG)
29

30
# 创建日志格式
31
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')
32

33
# 将处理器和格式绑定到日志记录器
34
file_handler.setFormatter(formatter)
35
database_handler.setFormatter(formatter)
36
logger.addHandler(file_handler)
37
logger.addHandler(database_handler)

上面的代码创建了一个日志记录器，并将日志级别设置为 DEBUG。然后，我们创建了一个文件处理器和一个数据库处理器，它们分别将日志记录到 app.log 文件和 logs 表中。最后，我们创建了一个日志格式，并将处理器和格式绑定到日志记录器