Python logging模块(二)

logging日志模块四大组件

• 1、日志器-logger
  提供程序使用日志的入口，可以创建日志对象。
• 2、处理器-Handler
  决定logger创建的日志记录输出位置。
• 3、格式器-Formatter
  决定logger创建的日志的输出格式。
• 4、过滤器-Filter
  过滤日志，使用更小的粒度工具。
• 5、示例
• 6、配置文件

总结：

• 日志器通过处理器决定输出日志位置，一个日志器可以设置多个处理器，把一个日志输出到不同的地方。
• 每个处理器都可以设置自己的格式器实现通一日志，以不同的格式输出到不同的地方。
• 每个处理器可以设置自己的过滤器实现日志的过滤。

1、日志器-logger

注意：logger设置等级，基于logging的等级，如果logging设置等级info，则所有的等级都是基于logging等级上。

2、处理器-Handler

• 创建Handler对象

• Handler方法

注意：handler设置等级，基于logging的严重等级和logger的严重等级。

3、格式器-Formatter

• 创建格式器对象

import logging

# fmt:格式化字符串，默认使用message的原始值
# datefmt：指定日期格式的字符串
logging.Formatter(fmt=None, datefmt=None)
1
2
3
4
5

4、过滤器-Filter

• 创建过滤器对象（一般不会用到过滤器）

# 创建对象
import logging


class IgnoreFilter1(logging.Filter):
    """小米文字的日志"""

    def filter(self, record):  # 固定写法
        return "小米" not in record.getMessage()


class IgnoreFilter2(logging.Filter):
    """小白文字的日志"""

    def filter(self, record):  # 固定写法
        return "小白" not in record.getMessage()


logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger()
logger.addFilter(IgnoreFilter1())
logger.addFilter(IgnoreFilter2())
logger.setLevel(0)

logger.debug("小明")
logger.info("小白")
logger.warning("小米")
logger.error("小华")
logger.critical("小七")

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

结果：

DEBUG:root:小明
ERROR:root:小华
CRITICAL:root:小七
1
2
3

5、示例

5.1 日志信息输出到控制台和文件

import logging

fmt_control = '控制台> %(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
fmt_file = '文件> %(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
# 创建控制台输出日志格式-格式器对象
formatter_control = logging.Formatter(fmt_control)
# 创建文件输出日志格式-格式器对象
formatter_file = logging.Formatter(fmt_file)

# 创建日志器对象
logger = logging.getLogger()
logger.setLevel(0)

# 创建控制台输出-处理器对象
handler_control = logging.StreamHandler()
# 设置控制台输出-处理器对象，输出格式
handler_control.setFormatter(formatter_control)
# 添加控制台处理对象到日志器中
logger.addHandler(handler_control)

# 创建文件输出-处理器对象
handler_file = logging.FileHandler("./a.log",encoding="utf-8")
# 设置文件输出-处理器对象，输出格式
handler_file.setFormatter(formatter_file)
# 添加文件输出处理器对象到文件中
logger.addHandler(handler_file)


logger.debug("---debug---")
logger.info("---info---")
logger.warning("---warning---")
logger.error("---error---")
logger.critical("---critical---")

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

5.2 日志文件按照时间分隔

TimedRotatingFileHandler参数：
- filename：log文件名字
- when：
```
	 Current 'when' events supported:
        # S - Seconds      ---按秒单位
        # M - Minutes     ---按分单位
        # H - Hours       --- 按小时单位
        # D - Days        ----  按天单位
        # midnight - roll over at midnight      --每天晚上12点，即24:00
        # W{0-6} - roll over on a certain day; 0 - Monday     ---每个星期几进行分类 （0代表星期一）
      # 不区分大小写
```
- interval：时间间隔（比如when="s",interval=2,则每2秒分隔一个文件）
- backupCount：保存日志文件的个数（超过的会抛弃，值为3，则会保存3个日志带有时间的文件，和一个本文件）
-encoding：编码格式(encoding="utf-8")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

示例：每秒生成一个log文件，最多保持3个，文本格式为utf-8

import logging.handlers
import time

logger = logging.getLogger()
logger.setLevel(0)
# 日志格式
fmt = "按照时间进行分割  %(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s"
formatter = logging.Formatter(fmt)
# 输出到文件，每日一个文件
fh = logging.handlers.TimedRotatingFileHandler(filename="./a.log", when='S', interval=1, backupCount=3, encoding="utf-8")
fh.setFormatter(formatter)
fh.setLevel(logging.INFO)
logger.addHandler(fh)

for i in range(5):
    time.sleep(1)
    logger.debug("---debug---")
    logger.info("---info---")
    logger.warning("---warning---")
    logger.error("---error---")
    logger.critical("---critical---")

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

结果：每过一秒会生成一个文件，保存起来，a.log文件保存的是最新的log文件。

5.3 日志文件按照文件大小分隔分隔

• logging.handlers.RotatingFileHandler
• 参数
  • filename:文件名
  • maxBytes：一个文件的最大字节（1KB=1024Bytes=1024*8Bit）
  • backupCount:保留文件的个数
  • encoding:编码格式

示例：每个log文件大小为10字节，最多保持3个，文本格式为utf-8

import logging.handlers

logger = logging.getLogger()
logger.setLevel(0)

fmt = "按照时间进行分割  %(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s"
formatter = logging.Formatter(fmt)
fh = logging.handlers.RotatingFileHandler(filename="./a.log", maxBytes=10, backupCount=3, encoding="utf-8")
fh.setFormatter(formatter)
fh.setLevel(logging.INFO)
logger.addHandler(fh)

for i in range(3):
    logger.debug("---debug---")
    logger.info("---info---")
    logger.warning("---warning---")
    logger.error("---error---")
    logger.critical("---critical---")
)

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

6、配置文件

使用config（还有字典等方式）

• log.ini

[loggers]
keys=root,simpleExample

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_simpleExample]
level=DEBUG
handlers=consoleHandler,fileHandler
qualname=simpleExample
propagate=0

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=simpleFormatter
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=WARNING
formatter=simpleFormatter
args=("file_config_log.log", "a")

[formatter_simpleFormatter]
format=%(asctime)s  %(name)s - %(levelname)s - %(message)s
datefmt=  %Y-%m-%d %H:%M:%S
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

• log.ini参数说明

[loggers]
# 定义logger模块，root是父类，必须存在
# 在python中通过logging.getLogger(NAME)调用，所有都继承root
keys=root,simpleExample

[handlers]
# 定义处理器
keys=consoleHandler,fileHandler

[formatters]
# 定义格式器
keys=simpleFormatter

[logger_root]
# 配置日志器的参数，以及使用的处理器
level=DEBUG
# 使用consoleHandler处理器
handlers=consoleHandler

[logger_simpleExample]
# 同理设置日志器参数，等级
level=DEBUG
# 使用两个处理器
handlers=consoleHandler,fileHandler
# logger名称，应用程序通过 logging.getLogger获取。对于不能获取的名称，则记录到root模块
qualname=simpleExample

# propagate 是否继承父类的log信息，0:否 1:是
# 如果设置为1，则root也会输出其他子类日志器的输出
propagate=0

[handler_consoleHandler]
# 处理器的类
class=StreamHandler
# 处理器等级
level=DEBUG
# 使用指定的格式器
formatter=simpleFormatter
# 输出到控制台,具体参数对应python的StreamHandler
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=WARNING
formatter=simpleFormatter

#  参数来源于对应类的参数
# class FileHandler(StreamHandler):
    """
    A handler class which writes formatted logging records to disk files.
    """
#    def __init__(self, filename, mode='a', encoding=None, delay=False):
args=("file_config_log.log", "a")

[formatter_simpleFormatter]
format=%(asctime)s  %(name)s - %(levelname)s - %(message)s
datefmt=  %Y-%m-%d %H:%M:%S
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

• main.py

import logging
import logging.config

# 使用配置文件配置logging
import time

logging.config.fileConfig("log.config")
logger = logging.getLogger("simpleExample")

# 使用logger
logger.debug("debug")
logger.info("info")
logger.warning("warning")
time.sleep(1)
logger.error("error")
logger.critical("critiacl")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16