Python logging系统

我们都知道python在2.x之后自带了一个模块import logging.

但是每次都要写log很麻烦，同时我想把info，debug之类的指令通过颜色分离开来。

于是写了一个简单的类似glog的小程序（完善是不可能完善的，checkeq这辈汁都不可能写的）

 import logging
 from colorlog import ColoredFormatter
 import sys
 import os

 def currentframe():
     """Return the frame object for the caller's stack frame."""
     try:
         raise Exception
     except:
         return sys.exc_info()[2].tb_frame.f_back
 _srcfile = os.path.normcase(currentframe.__code__.co_filename)

 logging._srcfile = _srcfile

 class myLogger(logging.Logger):
     def __init__(self):
         super(myLogger, self).__init__('my_logger')
         formatter = ColoredFormatter(
             "%(asctime)s - %(filename)s - [line:%(lineno)d] - %(log_color)s%(levelname)s: %(white)s%(message)s",
             datefmt = None,
             reset = True,
             log_colors = {
                 'DEBUG':    'cyan',
                 'INFO':     'green',
                 'WARNING':  'yellow',
                 'ERROR':    'red',
                 'CRITICAL': 'red',
             }
         )

         self.logger = logging.getLogger('example')
         handler = logging.StreamHandler()
         handler.setFormatter(formatter)
         self.logger.addHandler(handler)
         self.logger.setLevel(logging.DEBUG)

     def setLevel(self, opt):
         self.logger.setLevel(opt)

     def log(self, opt, str):
         if opt == 'debug':
             self.logger.debug(str)
         if opt == 'info':
             self.logger.info(str)
         if opt == 'warning':
             self.logger.warning(str)
         if opt == 'error':
             self.logger.error(str)
         if opt == 'critical':
             self.logger.critical(str)

     def log_if(self, opt, flag, str):
         if (flag == True):
             self.log(opt, str)

     def debug(self, str):
         self.logger.debug(str)

     def debug_if(self, flag, str):
         if (flag == True):
             self.logger.debug(str)

     def info(self, str):
         self.logger.info(str)

     def info_if(self, flag, str):
         if (flag == True):
             self.logger.info(str)

     def warning(self, str):
         self.logger.warning(str)

     def warning_if(self, flag, str):
         if (flag == True):
             self.logger.warning(str)

     def error(self, str):
         self.logger.error(str)

     def error_if(self, flag, str):
         if (flag == True):
             self.logger.error(str)

     def critical(self, str):
         self.logger.critical(str)

     def critical_if(self, flag, str):
         if (flag == True):
             self.logger.critical(str)

myLogger

还有一个demo

 import logging
 from myLogger import myLogger

 def demo():
     log = myLogger()
     log.log('debug', 'log debug test')

     log.log_if('info', True, 'log_if info test')
     log.log('warning', 'log warning test')
     log.log_if('warning', False, 'log_if warning test')
     log.log_if('error', True, 'log_if error test')
     log.log('critical', 'log critical test')

     print(' ')

     log.debug('log debug function test')
     log.info('log info function test')
     log.warning('log warning function test')
     log.error('log error function test')
     log.critical('log critical function test')

     print(' ')

     log.setLevel(logging.WARNING)
     log.info('log info function test set level')
     log.warning('log warning function test set level')
     log.error_if(True, 'log error if true')
     log.critical_if(False, 'log critical if false')

 if __name__ == '__main__':
     demo()

myLoggerDemo

效果就如下图：

下面稍微解释一下python的logging的原理：

我们以python2.7的logging模块为例子：

先查看logging最开始的一个函数currentframe()：

 # next bit filched from 1.5.2's inspect.py
 def currentframe():
     """Return the frame object for the caller's stack frame."""
     try:
         raise Exception
     except:
         return sys.exc_info()[2].tb_frame.f_back

这个函数的作用就是获得当前函数(caller)的在内存中的栈帧。

那么这个函数有什么用的呢？

下面还有一句话：

 # _srcfile is used when walking the stack to check when we've got the first
 # caller stack frame.
 #
 _srcfile = os.path.normcase(currentframe.__code__.co_filename)

通过currentframe()的信息，就能获得_srcfile，也就是这个python_root/lib/logging/__init__.py的filename。

而我们在import logging之后，例如通过log.info()，希望获得当前的filename，logging是怎么做的呢？

在logging/__init__.py中的class Logger(Filterer)中有一个函数findCaller()：

 def findCaller(self):
         """
         Find the stack frame of the caller so that we can note the source
         file name, line number and function name.
         """
         f = currentframe()
         #On some versions of IronPython, currentframe() returns None if
         #IronPython isn't run with -X:Frames.
         if f is not None:
             f = f.f_back
         rv = "(unknown file)", 0, "(unknown function)"
         while hasattr(f, "f_code"):
             co = f.f_code
             filename = os.path.normcase(co.co_filename)
             if filename == _srcfile:
                 f = f.f_back
                 continue
             rv = (co.co_filename, f.f_lineno, co.co_name)
             break
         return rv

显然这个函数的作用就是先获得当前这个findCaller的栈帧，然后不断地回退，一直到栈帧的文件信息不是当前logging/__init__.py为止，这时候就是我调用log.info()的具体位置了。

所以为了添加彩色弹幕信息，我们在新加一个myLogger类的时候，记得把logging中的_srcfile从python_root/lib/logging/__init__.py换成当前文件就好了，替换的方法和logging本身如出一辙。

至此我们理解和改造python log告一段落，但是glog的checkeq我是坚决不会写的（因为不会）。