• python日志管理

    logging

    简介

    日志级别等级排序：critical > error > warning > info > debug
    级别越高打印的日志越少，反之亦然，即

    • debug : 打印全部的日志( notset 等同于 debug )
    • info : 打印 info, warning, error, critical 级别的日志
    • warning : 打印 warning, error, critical 级别的日志
    • error : 打印 error, critical 级别的日志
    • critical : 打印 critical 级别
    通过 logging.basicConfig() 可以设置 root 的日志级别，和日志输出格式。
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',level=logging.DEBUG)

    • 1
    • 2

    logging 模块四大组件

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

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

Logger 可以包含一个或多个 Handler 和 Filter
Logger 与 Handler 或 Fitler 是一对多的关系
一个 Logger 实例可以新增多 个 Handler，一个 Handler 可以新增多个格式化器或多个过滤器，而且日志级别将会继承。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    1. 日志器- Logger
    • 日志记录器不直接实例化，而是通过模块级函数 logger.getlogger (name) 来实例化
    • 创建方法: logger = logging.getLogger(模块块儿名)
    • logger.setLevel(logging.ERROR) # 设置日志级别为 ERROR，即只有日志级别大于等于 ERROR 的日志才会输出
    • logger.addHandler(handler_name) # 为 Logger 实例增加一个处理器
    • logger.removeHandler(handler_name) # 为 Logger 实例删除一个处理器
    1. 处理器- Handler
    • 很多种，常用：StreamHandler，FileHandler，NullHandler
    • 创建方法：sh = logging.StreamHandler(stream=None)
    • ch.setLevel(logging.WARN) # 指定日志级别，低于WARN级别的日志将被忽略
    • ch.setFormatter(formatter_name) # 设置一个格式化器formatter
    • ch.addFilter(filter_name) # 增加一个过滤器，可以增加多个
    • ch.removeFilter(filter_name) # 删除一个过滤器
    1. 过滤器- Filter
    • 创建方法: filter = logging.Filter(name=‘’)
    1. 格式器- Formatter
    • 创建方法: formatter = logging.Formatter(fmt=None, datefmt=None)
    logging标准模块支持三种配置方式: dictConfig，fileConfig，listen。字典配置、文件配置、显式配置

    • 1

    应用

    一、
    logging.conf

    [loggers]
keys=root,simpleExample

[handlers]
keys=consoleHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

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

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

[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=

    • 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
    import logging
import logging.config

logging.config.fileConfig('logging.conf')

# create logger
logger = logging.getLogger('simpleExample')

# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    二、

    import logging
from logging.handlers import TimedRotatingFileHandler

class MylogHandler(logging.Logger):
    def __init__(self,name,level="DEBUG",stream=True,files=True):
        self.name = name
        self.level = level
        logging.Logger.__init__(self,self.name,level=self.level)
        if stream:
            self.__streamHandler__(self.level)
        if files:
            self.__filesHandler__(self.level)
    
    def __streamHandler__(self,level=None):
        handler = TimedRotatingFileHandler(filename=self.name+".log", when='D', interval=1, backupCount=15)
        handler.suffix = '%Y%m%d.log'
        handler.setLevel(level)
        formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
        
        handler.setFormatter(formatter)

        self.addHandler(handler) #将hander添加到logger上
        
    def __filesHandler__(self,level=None):
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        handler.setLevel(level)
        self.addHandler(handler)
        
    
if __name__ == '__main__':
    log = MylogHandler('test')
    log.info('this is a my log handler')

    • 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

    三、

    import os
import sys
import re
import logging
from logging import handlers

__all__ = ['Logger']


class Logger(object):
    # 日志级别关系映射
    DEFAULT_FMT = '%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
    LEVEL_DICT = {
        'debug': logging.DEBUG,
        'info': logging.INFO,
        'warning': logging.WARNING,
        'error': logging.ERROR,
        'critical': logging.CRITICAL
    }

    def __init__(
            self,
            log_obj,
            filename,
            level='info',
            when='s',
            backupCount=3,
            fmt=DEFAULT_FMT
    ):
        self.logger = logging.getLogger(log_obj)
        self.fmt = logging.Formatter(fmt)
        self.setLogDir(filename)
        self.logger.setLevel(self.LEVEL_DICT.get(level))  # level
        # self.logger.addHandler(self.setStream(self.fmt))
        self.logger.addHandler(self.setTimeRotator(
            filename=filename,
            when=when,
            backupCount=backupCount
        ))
        # self.logger.addHandler(self.setEmailHandler())

    def setLogDir(self, filename):
        _dir, _ = os.path.split(filename)
        if not os.path.exists(_dir):
            os.makedirs(_dir)

    # System standard output
    def setStream(self, fmt=None):

        handler = logging.StreamHandler(sys.stdout)

        if not fmt:
            handler.setFormatter(fmt)
        else:
            handler.setFormatter(self.fmt)
        return handler

    # Log record settings, include writing file, backup, etc.

    @classmethod
    def setTimeRotator(cls, filename, when, backupCount, encoding='utf-8', level=None, **kwargs):
        handler = handlers.TimedRotatingFileHandler(
            filename=filename,
            when=when,
            backupCount=backupCount,
            encoding=encoding,
            **kwargs
        )

        # Warnings: suffix issue is a `logging` package bug.
        # Must add `.log` string to `suffix` attribute format,
        # Or `TimedRotatingFileHandler` can't backup log files.
        # Specific formatting can be read in `logging.TimedRotatingFileHandler`
        if level is None:
            handler.setLevel(cls.LEVEL_DICT.get('info'))
        else:
            handler.setLevel(level)
        handler.suffix = "%Y-%m-%d_%H-%M-%S.log"
        handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$")
        handler.setFormatter(logging.Formatter(cls.DEFAULT_FMT))  # 设置文件里写入的格式
        return handler

    # TODO: email handler.
    def setEmailHandler(self, mailhost, fromaddr, toaddrs, subject,
                        credentials=None, secure=None, timeout=5.0, level='info'):
        email = handlers.SMTPHandler(
            mailhost,
            fromaddr,
            toaddrs,
            subject,
            credentials=None,
            secure=None,
            timeout=5.0
        )

        email.setLevel(self.LEVEL_DICT.get('error'))
        email.setFormatter(logging.Formatter(
            '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'))
        return email


    • 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

    四、

    LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '[%(asctime)s] [%(levelname)s] %(message)s'
        },
    },
    'handlers': {
        # 输出日志的控制台
        'console': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'verbose'
        },
        # 输出日志到文件，按日期滚动
        'file': {
            'level': 'DEBUG',
            'class': 'logging.handlers.TimedRotatingFileHandler',
            # TimedRotatingFileHandler的参数
            # 参照https://docs.python.org/3/library/logging.handlers.html#timedrotatingfilehandler
            # 目前设定每天一个日志文件
            'filename': 'logs/all_info.log',
            'when': 'midnight',
            'interval': 1,
            'backupCount': 100,
            'formatter': 'verbose'
        },
        # 发送邮件，目前腾讯云、阿里云的服务器对外发送邮件都有限制，暂时不使用
        'email': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'include_html': True,
        }
    },
    'loggers': {
        # 不同的logger
        'django': {
            'handlers': ['console', 'file'],
            'level': 'INFO',
            'propagate': True,
        },
    },
}


logger = logging.getLogger('django')  # 日志捕捉方法
logging.config.dictConfig(settings.LOGGING)

logger.error(e.__class__.__name__)
logger.error('视图报错，报错详情如下:\n%s' % traceback.format_exc())  # todo 显示报错第几行

    • 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

    loguru

    • 配置
    from loguru import logger
logger.add('file_{time}.log', format="{name} {level} {message}", level="INFO", rotation='5 MB', encoding='utf-8', , rotation="1 week"， compression="zip"))  
# 根据时间为日志命名，每5MB新建一个, 一周清理一次，压缩节省空间

logger.add('out.log', backtrace=True, diagnose=True, encoding='utf-8')
完整描述异常：包括内存地址，可能泄露敏感数据

logger.add('json.log', serialize=True, encoding='utf-8') #保存为json格式日志

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 使用
    # 装饰器
from loguru import logger
@logger.catch
def func(x, y, z):
    return 1 / (x + y + z)

# 上下文
with logger.catch():
    func(0, 1, -1)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    from loguru import logger
from utils.path_config import ConfigFilePath


class DWLog(object):
    def __init__(self, module):
        self.module = module
        self.log_obj = logger
        self.log_obj.add(ConfigFilePath().log_file(self.module), format="{time} | {message}",
                         rotation="20 MB", encoding='utf-8', retention="30 days",
                         enqueue=True)
        # self.log_obj.add(ConfigFilePath().log_file("error"), format="{time} | {message}",
        #                  rotation="20 MB", encoding='utf-8', retention="30 days", level='ERROR', enqueue=True)

    def log(self, msg):
        self.log_obj.info("[%s]--%s" % (self.module, msg))


_ = DWLog('hot')
log, logger = _.log, _.log_obj  # 打印和保存log,catch 异常
log("hot_word_trend ok")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
  • 相关阅读:
    怎样优雅地增删查改（二）：扩展身份管理模块
    编写程序将一个子串插入到主串中
    数值的扩展方法以及新增数据类型BigInt
    django实现用户的注册、登录、注销功能
    Windows11轻松设置v1.06绿色版
    通讯录（纯C语言实现）
    应用程序接口（API）安全的入门指南
    [最优化DP]决策单调性
    关于MAC如何安装ubuntu
    聊聊SpringBoot单元测试
  • 原文地址：https://blog.csdn.net/shunjianxaioshi/article/details/125970146