详解Python自建logging模块

import logging
logger = logging.getLogger()
logging.basicConfig()
logger.setLevel('DEBUG')
logger.debug('logsomething')
#输出
out>>DEBG:root:logsomething

CRITICAL = 50
ERROR = 40
WARNING = 30
INFO 20
DEBUG = 10
NOTEST = 0

#主干代码
/usr/lib/python2.7/logging/__init__.py
#扩展的handler和config
/usr/lib/pyhon2.7/logging/config.py
/usr/lib/python2.7/loging/handlers.py

class LogRecord(object):
 #代表一条日志的类
 def getMessage(self):
  #获取self.msg
 def markLogRecord(dict):
 #这个方法很重要，生成一个空的LogRecord，然后通过一个字典，直接更新LogReocrd中的成员变量
 rv = LogRecord(None, None, "", 0, "", (), None, None)
 rv.__dict__.update(dict)
 return rv

#通过字典的方式，输出格式化字符串
print('%(name)s:%(num)d'%{'name':'my_name', 'num' : 100})
out >>>my_name:100

class Formatter(object):
 def __init__(self, fmt=None, datefmt = None):
  if fmt:
   self._fmt = fmt
  else:
   #默认的format
   self._fmt = "%(message)s"
 def format(self, record)
  #使用self._fmt进行格式化
  s = self._fmt %record.__dict__
  return s

class Filter(object):
 def __init__(self, name=''):
  self.name = name
  self.nlen = len(name)
 def filter(self, record):
  #返回1表示record通过，0表示record不通过
  if self.nlen == 0:
   return 1
  elif self.name == record.name:
   return 1
  #record.name不是以filter开头
  elif record.name.find(self.name, 0, self.nlen) != 0:
   return 0
  #最后一位是否为
  return (record.name[self.nlen] == '.')
class Filterer(object):
 #这个类其实是定义了一个self.filters = []的列表管理多个filter
 def addFilter(self, filter):
 def removefilter(self, filter):
 def filter(self, record):
 #使用列表中所有的filter进行筛选，任何一个失败都会返回0
 #例如：
  #filter.name = 'A', filter2.name='A.B', filter2.name = 'A, B, C'
  #此时record.name = 'A,B,C,D'这样的record才能通过所有filter的筛选

class Handler(Filterer):
 def __init__(self, level = NOTEST)
  #handler必须有level属性
  self.level = _checkLevel(level)
 def format(self, record):
  #使用self.formatter, formattercord
 def handler(self, record):
  #如果通过filter的筛选，则emit这条log
  rv = self.filter(record)
  self.emit(record)
 def emit(self, record):
  #等待子类去实现

class StreamHandler(Handler):
 def __init__(self, stream = None):
  if stream is None:
   stream = sys.stderr
  self.stream = stream
 def emit(self, record):
  #将record的信息写入流
  #处理一些编码的异常
  fs = '%s\n' #每条日志都有换行
  stream = self.stream
  stream.write(fs%msg)

class FileHandler(StreamHandler):
 def __init__(self, filename, mode='a')
  #append方式打开一个文件
  StreamHandler.__init__(self, self._open())
 def emit(self, record):
  #和streamhandler保持一致
  StreamHandler.emit(self, record)

class Logger(Filterer):
 def __init__(self, name, level=NOTEST)
  #handler列表
  self.handlers = []
  self.level = _checklevel(level)
 def addHandler(self, hdlr):
 def removeHandler(self, hdlr):
 def _log(self, level, msg, args, exc_info=None, extra=None):
  #在_log函数中创建了一个LogRecord对象
  record = self.makeRecord(self.name, level, fn, lno, msg, args, exc_info, func, extra)
  #交给handle函数
  self.handle(record)
 def handle(self, reord):
  #进行filter,然后调用callHandlers
  if(not self.disabled) and self.filter(record):
   self.callHandlers(record)
 def callHandlers(self, record):
  #从当前logger到所有的父logger,递归的handl传入的record
  c = self
  while c:
   for hdlr in c.handlers:
    hdlr.handle(record) #进入handler的emit函数发送log
   ....
   c = c.parent

def process(self, msg, kwargs):
 '''
 Normally,you'll only need to overwrite this one method in a LoggerAdapter subclass for your specific needs.
 '''

import logging
import random
L=logging.getLogger('name')
#定义一个函数，生成0~1000的随机数
def func():
 return random.randint(1,1000)
class myLogger(logging.LoggerAdapter):
 #继承LoggerAdapter，重写process，生成随机数添加到msg前面
 def process(self,msg,kwargs):
  return '(%d),%s' % (self.extra['name'](),msg) ,kwargs
#函数对象放入字典中传入 
LA=myLogger(L,{'name':func})
#now,do some logging
LA.debug('some_loging_messsage')
out>>DEBUG:name:(167),some_loging_messsage