Python About 日志系统(一)

缺乏、安全感 2022-01-26 05:39 193阅读 0赞

### Logging详解 ###

日志安装下面四个层次来完成日志的功能

1.  Logger是一个接口用来暴露出来给应用使用
2.  Handlers是发送日志记录(由logger创建)到规定的目的地, 如 email. etc
3.  Filters是一个过滤的机制
4.  Formatters是输入日志的格式

import logging
    # 没有创建logger, 则默认是root logger, 直接打印在屏幕上
    # root logger 默认的level 是warning, 所以这里设置成debug, 才能打印info的日志
    # 科普下日志级别, level往上是允许的
    # 日志级别
    CRITICAL = 50
    FATAL = CRITICAL
    ERROR = 40
    WARNING = 30
    WARN = WARNING
    INFO = 20
    DEBUG = 10
    NOTSET = 0
    # 设置了root logger的format，包括时间，logger名字，levelname等
    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s:%(name)s:%(levelname)s:%(message)s')
    logging.warning('this is warning')
    logging.info('this is info')
    """ #输出： 2018-01-30 15:50:28,761:root:WARNING:this is warning 2018-01-30 15:50:28,761:root:INFO:this is info """
    
    # 创建一个新的apps 的logger， 如果logger不设置，就会用root logger那套（打印到屏幕和上面的格式）
    # 因为它是会默认传播到祖先logger
    logger = logging.getLogger('apps')
    logger.setLevel(logging.DEBUG)
    # 是否传播这个日志到祖先logger, 如果设置了False 就不会传到root logger(祖先Logger)的
    # 默认StreamHandler那里， 也就是不会打印在页面上
    logger.propagate = False
    # 添加handler, 决定日志落地到哪里，可以多个
    # 这个是记录在文件的Handler
    apps_handler = logging.FileHandler(filename="apps.log")
    # 设置这个handler的处理格式， 实例化一个Formatter对象
    apps_formatter = logging.Formatter('%(asctime)s:%(name)s:%(levelname)s:%(message)s')
    apps_handler.setFormatter(apps_formatter)
    logger.addHandler(apps_handler)
    # 日志会打印到apps.log, 并且不会输出到屏幕（如果logger.propagate=True就会）
    logger.debug('shit')
    
    # 定义一个新的logger
    child_logger = logging.getLogger('apps.owan')
    # 因为这个child_logger 是apps.owan， 它是继承了apps这个logger
    # 这个child_logger.propagate 默认是True
    # 所以还是会传到它的祖先logger 也就是apps
    child_logger.info('haha')
    # 所以这个info 是会传播到apps 所以apps.log会出现这个日志。
    # 这里充分说明logger的继承关系
    
    >>> tail apps.log
    # apps ，apps.owan 的logger都把日志写到apps.log了, 而且格式一样
    # 因为child_logger没有设置handler 和 formatter, 默认传播到祖先那里apps 的logger
    2018-01-30 16:00:10,258:apps:DEBUG:apps logger coming
    2018-01-30 16:00:10,258:apps.owan:INFO:i am apps child_logger

### 日志类一 ###

import logging
    import os
    from douban_scrapy import settings
    from logging.handlers import RotatingFileHandler
    from logging import StreamHandler
    
    # 直接继承logging.Logger 那么就是说这个类就是一个Logger， 有了Logger所有方法
    # 只是在类里面添加一些内部方法，让logger 封装addhandler, setformatter等方法
    class LogHandler(logging.Logger):
        # 单例模式
        _instance = None
        def __new__(cls, *args, **kwargs):
            if not cls._instance:
                # 一开始居然用了 cls()来实例化 导致无限次调用
                # cls._instance = cls(*args, **kwargs)
                cls._instance = object.__new__(cls, *args, **kwargs)
            return cls._instance
    
        def __init__(self, name, level=logging.DEBUG, to_stream=True, to_file=True):
            self.name = name
            self.level = level
            self.formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
            # 错误的， 继承了logger 本身就是logger 不用再self.logger=xxx 这样变成了一个新的变量
            #self.logger = logging.Logger(name=name, level=level)
            super(LogHandler, self).__init__(name=name, level=level)
    
            # 写文件
            if to_file:
                self.__setFileHandler__()
    
            # 写标准输出
            if to_stream:
                self.__setSteamHandler__()
    
        def __setSteamHandler__(self):
            stream_handler = StreamHandler()
            stream_handler.setFormatter(self.formatter)
            self.addHandler(stream_handler)
    
        def __setFileHandler__(self):
            log_path = os.path.join(settings.LOG_DIR, self.name +'.log')
            handler = RotatingFileHandler(log_path, maxBytes=1024, backupCount=5)
            handler.setFormatter(self.formatter)
            self.addHandler(handler)
    
    
    if __name__ == '__main__':
        logger = LogHandler('scrapy')
        logger2 = LogHandler('scrapy')
        print logger, logger2
        logger.info('haha')

日志类二(实现大致相同)

import os
    import logging
    from logging.handlers import TimedRotatingFileHandler
    
    CURRENT_PATH = os.path.dirname(os.path.abspath(__file__))
    ROOT_PATH = os.path.join(CURRENT_PATH, os.pardir)
    LOG_PATH = os.path.join(ROOT_PATH, 'log')
    
    class LogHandler(logging.Logger):
        """ LogHandler """
    
        def __init__(self, name, level=DEBUG, stream=True, file=True):
            self.name = name
            self.level = level
            logging.Logger.__init__(self, self.name, level=level)
            if stream:
                self.__setStreamHandler__()
            if file:
                self.__setFileHandler__()
    
        def __setFileHandler__(self, level=None):
            """ set file handler :param level: :return: """
            file_name = os.path.join(LOG_PATH, '{name}.log'.format(name=self.name))
            # 设置日志回滚, 保存在log目录, 一天保存一个文件, 保留15天
            file_handler = TimedRotatingFileHandler(filename=file_name, when='D', interval=1, backupCount=15)
            file_handler.suffix = '%Y%m%d.log'
            if not level:
                file_handler.setLevel(self.level)
            else:
                file_handler.setLevel(level)
            formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
    
            file_handler.setFormatter(formatter)
            self.file_handler = file_handler
            self.addHandler(file_handler)
    
        def __setStreamHandler__(self, level=None):
            """ set stream handler :param level: :return: """
            stream_handler = logging.StreamHandler()
            formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
            stream_handler.setFormatter(formatter)
            if not level:
                stream_handler.setLevel(self.level)
            else:
                stream_handler.setLevel(level)
            self.addHandler(stream_handler)
    
        def resetName(self, name):
            """ reset name :param name: :return: """
            self.name = name
            self.removeHandler(self.file_handler)
            self.__setFileHandler__()
    
    
    if __name__ == '__main__':
        log = LogHandler('test')
        log.info('this is a test msg')

### 定义Log的两种方法 ###

*  第一种: 实例化logger = logging.logger 然后手动给logger添加addHandler, addFilter, handler.setFormatter, 这样的形式来获取logger
 *  第二种: 使用logging.config.dictConfig来从配置文件生成logger

import logging
    
    # 没有创建logger, 默认是root logger， 直接打印在屏幕
    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s:%(name)s:%(levelname)s:%(message)s')
    logging.warning('this is warning')
    logging.info('this is info')
    
    logger = logging.getLogger('apps')
    # 下面两行不写不会创建文件并记录信息到log里面
    apps_handler = logging.FileHandler(filename="apps.log")
    logger.addHandler(apps_handler)
    
    logger.setLevel(logging.DEBUG)
    logger.info('shis')
    print logger.handlers
    print logger
    
    2019-05-28 10:54:37,671:root:WARNING:this is warning
    2019-05-28 10:54:37,671:root:INFO:this is info
    2019-05-28 10:54:37,671:apps:INFO:shis
    [<logging.FileHandler object at 0x7f4147aa2c50>]
    <logging.Logger object at 0x7f4147aa2c10>

上面流程讲解：

*  首先 logging.basicConfig 配置的是root logger 的StreamHandler 的格式，即打印在终端的内容
 *  然后新的apps logger 都是root logger的子，输出的时候，同时会输出到root logger, 除非 logger.propagate = False。
 *  所以如果没有 logging.basicConfig这个对root logger的配置，app logger就会只发送内容到自己的handlers

### logging通过配置文件配置 ###

PATTERN = { 
        'version': 1,
        'formatters': { 
            'normal': { 
                'format': '%(name)s %(asctime)s %(levelname)s %(message)s',
                'datefmt': '%Y-%m-%d %H:%M:%S'
            },
            'raw': { 
                'format': '%(message)s',
            },
        },
        'handlers': { 
            'console': { 
                'class': 'logging.StreamHandler',
                'stream': 'ext://sys.stdout',
                'formatter': 'normal',
            },
            'root': { 
                'class': 'logging.handlers.WatchedFileHandler',
                'formatter': 'normal',
                'filename': RUNTIME_HOME + '/var/log/root.log',
                'mode': 'a',
                'level': 'INFO',
            },
            'extapi': { 
                'class': 'logging.handlers.WatchedFileHandler',
                'formatter': 'normal',
                'filename': RUNTIME_HOME + '/var/log/ext_api.log',
                'mode': 'a',
                'level': 'DEBUG',
            },
            'api': { 
                'class': 'logging.handlers.WatchedFileHandler',
                'formatter': 'normal',
                'filename': RUNTIME_HOME + '/var/log/api.log',
                'mode': 'a',
                'level': 'DEBUG',
            },
        },
        'loggers': { 
            'API': { 'level': 'DEBUG',
                    'handlers': ['api'],
                    },
            'EXTAPI': { 'level': 'DEBUG',
                       'handlers': ['extapi'],
                       },
            'requests.packages.urllib3.connectionpool': { 'level': 'ERROR'},
        },
        'root': { 
            'handlers': ['root',],
            'level': 'INFO',
        }
    }

初始化logging

logging.config.dictConfig(log_confi.PATTERN)

这样就能从配置文件初始化好所有的logger, 而不用通过addHandlers等方法动态修改logger去写日志了