logging模块是python中的常用模块，我计划用两到三篇文章来详细的介绍一下这个模块的用法。第一篇文章主要是讲logging的主干源码，如果想直接看logging的用法，可以等第二篇。
参考的logging版本是python2.7.3，我将logging源码加上了中文注释放在我的github上
https://github.com/Stan-He/python_learn/tree/master/learn_logging
1.开始
最开始，我们用最短的代码体验一下logging的基本功能
import logging
loger=logging.getLoger()
logging.basicConfig()
loger.setLevel('DEBUG')
loger.debug('logsomething')
#输出
out>>DEBUG:root:logsomething
- 第一步，通过logging.getLoger函数，获得一个loger对象，但这个对象暂时是无法使用的。
- 第二步，logging.basicConfig函数，进行一系列默认的配置，包括format、handler等。
- 第三步、loger调用setLevel函数定义日志级别为DEBUG
- 最后，logger调用debug函数，输出一条debug级别的message，显示在了标准输出上
2.logging中的日志级别
logging在生成日志的时候，有一个日志级别的机制，默认有以下几个日志级别：
CRITICAL = 50
ERROR = 40
WARNING = 30
INFO = 20
DEBUG = 10
NOTSET = 0
每一个logger对象，都有一个日志级别，它只会输出高于它level的日志。如果一个logger的level是INFO，那么调用logger.debug()是无法输出日志的，而logger.warning()能够输出。
一般来说，以上的6个日志级别完全满足我们日常使用了。
3.logging中的基础类
logging是python中的一个基础模块，它在python中的源码位置如下：
#主干代码
/usr/lib/python2.7/logging/__init__.py
#扩展的handler和config
/usr/lib/python2.7/logging/config.py
/usr/lib/python2.7/logging/handlers.py
组成logging的主干的几个基础类都在__init__.py中：
3.1 第一个基础类 LogRecord
一个LogRecord对象，对应了日志中的一行数据。通常包含：时间、日志级别、message信息、当前执行的模块、行号、函数名……这些信息都包含在一个LogRecord对象里。
LogRecord对象可以想象成一个大字典
class LogRecord(object):
#代表一条日志的类
def getMessage(self):
#获取self.msg
def makeLogRecord(dict):
#这个方法很重要，生成一个空的LogRecord，然后通过一个字典，直接更新LogRecord中的成员变量
rv = LogRecord(None, None, "", 0, "", (), None, None)
rv.__dict__.update(dict)
return rv
3.2 第二个基础类 Formatter
Formatter对象是用来定义日志格式的，LogRecord保存了很多信息，但是打日志的时候我们只需要其中几个，Formatter就提供了这样的功能，它依赖于python的一个功能：
#通过字典的方式,输出格式化字符串
print '%(name)s:%(num)d' % {'name':'my_name','num': 100}
out>>my_name:100
如果说LogRecord是后面的那个字典，那么Formatter就是前面的那个格式字符串……的抽象
重要的代码如下：
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
3.3 第三个基础类 Filter和Filterer
Filter类，功能很简单。Flter.filter()函数传入一个LogRecord对象，通过筛选返回1，否则返回0。从代码中可以看到，其实是对LogRecord.name的筛选。
Filterer类中有一个Filter对象的列表，它是一组Filter的抽象。
重要的代码如下：
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
#例如:
#filter1.name='A',filter2.name='A.B',filter3.name='A.B.C'
#此时record.name='A.B.C.D'这样的record才能通过所有filter的筛选
4. logging中的高级类
有了以上三个基础的类，就可以拼凑一些更重要的高级类了，高级类可以实现logging的重要功能。
4.1 Handler——抽象了log的输出过程
- Handler类继承自Filterer。Handler类是log输出这个过程的抽象。
- 同时Handler类具有一个成员变量self.level,在第二节讨论的日志级别的机制，就是在Handler中实现的。
- Handler有一个emit(record)函数，这个函数负责输出log，必须在Handler的子类中实现。
重要代码如下：
class Handler(Filterer):
def __init__(self,level=NOTSET):
#handler必须有level属性
self.level=_checkLevel(level)
def format(self,record):
#使用self.formatter，formatrecord
def handle(self,record):
#如果通过filter的筛选，则emit这条log
rv=self.filter(record)
self.emit(record)
def emit(self，record):
#等待子类去实现
接下来看两个简单的handler的子类，其实在logging源码中，有一个handler.py专门定义了很多更复杂的handler，有的可以将log缓存在内存中，有的可以将log做rotation等
4.1.1 StreamHandler
最简单的handler实现，将log写入一个流中，默认的stream是sys.stderr
重要的代码如下：
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)
4.1.2 FileHandler
将log输出到文件的handler，继承自StreamHandler
重要代码如下：
class FileHandler(StreamHandler):
def __init__(self,filename, mode='a'):
#append方式，打开一个文件
StreamHandler.__init__(self, self._open())
def emit(self,record):
#和streamhandler保持一致
StreamHandler.emit(self, record)
4.2 Logger —— 一个独立的log管道
什么是logger？
- logger类继承自Filterer，
- logger对象有logger.level日志级别
- logger对象控制多个handler：logger.handlers=[]
- logger对象之间存在父子关系
简单的来说，logger这个类，集中了我们以上所有的LogRecord类、Filter类、Formatter类、handler类。首先，logger根据输入生成一个LogRecord对象，经过Filter和Formatter之后，再通过self.handlers列表中的所有handler，把log发送出去。一个logger中可能有多个handler，可以实现把一份log放到多个任意的位置。
重要代码：
class Logger(Filterer):
def __init__ (self,name,level=NONSET):
#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,record):
#进行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
4.3 Manager —— 管理logger的类
Manager这个类，对用户其实是不可见的，如果生成了Logger，Manager就会自动存在，Manager对象负责管理所有的Logger。
logger和manager的关系，总结了一下几条：
- Logger是输出log的对象，Manager类提供了管理多个Logger的功能。
- 一个程序中只能有一个manager对象，生成manager时，必定也会生成RootLogger，manager对象中的self.root指向了RootLogger
- manager对象中的self.loggerDict，这个字典保存了当前所有的logger对象（不包含rootlogger）
- 如果使用logging.getLogger的name为空，那么默认指向了name为'root'的RootLogger
- 如果使用logging.getLogger的name不为空，生成的logger会自动挂载到RootLogger下，除非指定其他的父logger
- 其他的logger通过name建立父子关系
父子关系示例：
loger1=logging.getLogger('A')
loger2=logging.getLogger('A.B')
#loger2的父loger是loger1
loger2.parent
out>><logging.Logger object at 0xb7230d6c>
#loger1的父loger是rootlogger
loger1.parent
out>><logging.RootLogger object at 0xb7230b6c>
这些关系都在manager中进行管理
重要的代码：
class Manager(object):
def getLogger(self,name):
#生成一个logger，将logger中的manager指向self
#维护所有logger的父子关系
def _fixupParents(self,aloger):
def _fixupChildren(self,ph,aloger):
#修复所有logger的父子关系
4.4 LoggerAdapter —— 对标准logger的一个扩展
LogRecord这个大字典中提供的成员变量已经很多，但是，如果在输出log时候仍然希望能够夹带一些自己想要看到的更多信息，例如产生这个log的时候，调用某些函数去获得其他信息，那么就可以把这些添加到Logger中，LoggerAdapter这个类就起到这个作用。
LoggerAdapter这个类很有意思，如果不做什么改动，那么LoggerAdapter类和Logger并没有什么区别。LoggerAdapter只是对Logger类进行了一下包装。
LoggerAdapter的用法其实是在它的成员函数process()的注释中已经说明了：
def process(self, msg, kwargs):
"""
Normally, you'll only need to override this one method in a
LoggerAdapter subclass for your specific needs.
"""
也就是说重写process函数，以下是一个例子：
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
5. logging中的config函数
5.1 def basicConfig(**kwargs)
basicConfig函数将对各种参数进行配置，如果不传入参数，则进行默认配置：
- format配置
- handler配置
- level配置
