python logging模块源码分析

标签：内容   技术   另一个   bst   hiera   高级   instance   parent   roc   

阅读目录

一、源码分析

二、流程图

一、源码分析

1 创建logger对象

logger = logging.getLogger(__name__)
# 1.加载文件，创建以下单例对象
root = RootLogger(WARNING)
Logger.root = root
Logger.manager = Manager(Logger.root)
_loggerClass = Logger

# 2.getLogger（）
if name:
    return Logger.manager.getLogger(name)
else:
    return root

# 3.看一下getLogger（）干了些什么  
class Manager(object):
    def __init__(self, rootnode):
        """
        Initialize the manager with the root node of the logger hierarchy.
        """
        self.root = rootnode
        self.disable = 0
        self.emittedNoHandlerWarning = False
        self.loggerDict = {}
        self.loggerClass = None
        self.logRecordFactory = None

    def getLogger(self, name):
        rv = None
        if not isinstance(name, str):
            raise TypeError('A logger name must be a string')
        _acquireLock()  # 加了一个可重入锁，因为下面会操作字典，保证线程安全
        try:
            if name in self.loggerDict:    # self.loggerDict第一次初始化为空，所有会走else语句
                rv = self.loggerDict[name]
                if isinstance(rv, PlaceHolder):
                    ph = rv
                    rv = (self.loggerClass or _loggerClass)(name)
                    rv.manager = self
                    self.loggerDict[name] = rv
                    self._fixupChildren(ph, rv)
                    self._fixupParents(rv)
            else:
                rv = (self.loggerClass or _loggerClass)(name)    # self.loggerClass第一次初始化为空，所以调用的是Logger单例初始化
                rv.manager = self
                self.loggerDict[name] = rv    # 在初始化字典内添加了 {__name__:logger_obj}
                self._fixupParents(rv)    # 很重要的一步，看一下吧
        finally:
            _releaseLock()
        return rv

# 3. _fixupParents() 绑定上一级logger对象
    def _fixupParents(self, alogger):
        name = alogger.name
        i = name.rfind(".")   #第一次进来，__name__对应__main__也是个字符串，所有i=0
        rv = None
        while (i > 0) and not rv:
            substr = name[:i]
            if substr not in self.loggerDict:
                self.loggerDict[substr] = PlaceHolder(alogger)
            else:
                obj = self.loggerDict[substr]
                if isinstance(obj, Logger):
                    rv = obj
                else:
                    assert isinstance(obj, PlaceHolder)
                    obj.append(alogger)
            i = name.rfind(".", 0, i - 1)
        if not rv:
            rv = self.root 
        # 给logger对象绑定一个parent属性指向另一个logger对象，也就形成了一个单向链表
        # 第一次进来rv是RootLogger，所以RootLogger应该为整个链表的头节点
        alogger.parent = rv   

2 logger.debug()

class Logger(Filterer):
    def __init__(self, name, level=NOTSET):
        """
        Initialize the logger with a name and an optional level.
        """
        Filterer.__init__(self)
        self.name = name    # 此时name = __main__
        self.level = _checkLevel(level)
        self.parent = None
        self.propagate = True
        self.handlers = []
        self.disabled = False
        self._cache = {}
    # 1.看一下调用的debug做了什么
    def debug(self, msg, *args, **kwargs):
        # 循环判断多级（parent）level是否有大于当前设置的level，没有则退出结束流程
        if self.isEnabledFor(DEBUG):
            self._log(DEBUG, msg, args, **kwargs)   
    # 2. 看一下_log干了些啥
    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
        sinfo = None
        if _srcfile:  # 获取到当前文件的路径
            try:
                # 3.查看是被谁调用的，fn-文件路径,lno-代码行,func-module,sinfo-缓存获取的数据
                fn, lno, func, sinfo = self.findCaller(stack_info) 
            except ValueError: # pragma: no cover
                fn, lno, func = "(unknown file)", 0, "(unknown function)"
        else: # pragma: no cover
            fn, lno, func = "(unknown file)", 0, "(unknown function)"
        # 4.处理异常信息，为空不走
        if exc_info:
            if isinstance(exc_info, BaseException):
                exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
            elif not isinstance(exc_info, tuple):
                exc_info = sys.exc_info()
        # 5.开始了新大陆，创建一条记录
        record = self.makeRecord(self.name, level, fn, lno, msg, args,
                                 exc_info, func, extra, sinfo)
        # 6. 创建的record对象交给handle处理
        self.handle(record)
    
    # 5.看看record干了些什么
    def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
                   func=None, extra=None, sinfo=None):
        # 5.1这里去初始化了一个新的对象class LogRecord(object):我们在下面在展开谈
        rv = _logRecordFactory(name, level, fn, lno, msg, args, exc_info, func,
                             sinfo)
        if extra is not None:
            for key in extra:
                if (key in ["message", "asctime"]) or (key in rv.__dict__):
                    raise KeyError("Attempt to overwrite %r in LogRecord" % key)
                rv.__dict__[key] = extra[key]
        return rv
    # 6.看看handle干了些什么
    def handle(self, record):
        # disabled走到这还是False， 紧接着就去过筛选器了
        if (not self.disabled) and self.filter(record):
            # 6.2 将记录器传递给所有相关处理程序处理
            self.callHandlers(record)
   
    # 6.1 这里可以继续去探索logging模块的主要组成对象Filter功能
    def filter(self, record):
        rv = True # 默认返回True
        for f in self.filters:
            if hasattr(f, 'filter'):
                result = f.filter(record)
            else:
                result = f(record) # assume callable - will raise if not
            if not result:
                rv = False
                break
        return rv   

    # 6.2 handler处理器处理
    def callHandlers(self, record):
        c = self
        found = 0
        # 循环遍历此记录器及其父级的所有处理程序
        while c:
            # 这里如果有自定制的handler（FileHandler，StreamHandler），肯定会有值
            for hdlr in c.handlers:
                found = found + 1
                if record.levelno >= hdlr.level:
                    hdlr.handle(record)  # 根据不同的定制handler走到对应的handle方法
            # propagate=False 则记录器为最高级别
            if not c.propagate:
                c = None    #break out
            else:
                c = c.parent
        # 没有设置handler处理
        if (found == 0):
            if lastResort:  # 其实就是去初始化了一个logging的另一个对象Handler
                if record.levelno >= lastResort.level:
                    lastResort.handle(record)   # 最后在来刨一下Handler源码，见小节4
            elif raiseExceptions and not self.manager.emittedNoHandlerWarning:
                sys.stderr.write("No handlers could be found for logger"
                                 " \"%s\"\n" % self.name)
                self.manager.emittedNoHandlerWarning = True

3 LogRecord(object)

class LogRecord(object):
    """初始化了很多变量用来在之后记录log，包括去获取线程，进程的名称，pid等"""
    def __init__(self, name, level, pathname, lineno,
                 msg, args, exc_info, func=None, sinfo=None, **kwargs):
        ct = time.time()
        self.name = name
        self.msg = msg
        if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)
            and args[0]):
            args = args[0]
        self.args = args
        self.levelname = getLevelName(level)
        self.levelno = level
        self.pathname = pathname
        try:
            self.filename = os.path.basename(pathname)
            self.module = os.path.splitext(self.filename)[0]
        except (TypeError, ValueError, AttributeError):
            self.filename = pathname
            self.module = "Unknown module"
        self.exc_info = exc_info
        self.exc_text = None      # used to cache the traceback text
        self.stack_info = sinfo
        self.lineno = lineno
        self.funcName = func
        self.created = ct
        self.msecs = (ct - int(ct)) * 1000
        self.relativeCreated = (self.created - _startTime) * 1000
        if logThreads:
            self.thread = threading.get_ident()
            self.threadName = threading.current_thread().name
        else: # pragma: no cover
            self.thread = None
            self.threadName = None
        if not logMultiprocessing: # pragma: no cover
            self.processName = None
        else:
            self.processName = 'MainProcess'
            mp = sys.modules.get('multiprocessing')
            if mp is not None:
                # Errors may occur if multiprocessing has not finished loading
                # yet - e.g. if a custom import hook causes third-party code
                # to run when multiprocessing calls import. See issue 8200
                # for an example
                try:
                    self.processName = mp.current_process().name
                except Exception: #pragma: no cover
                    pass
        if logProcesses and hasattr(os, 'getpid'):
            self.process = os.getpid()
        else:
            self.process = None

4 Handler(Filterer)

class Handler(Filterer):
    def __init__(self, level=NOTSET):
        Filterer.__init__(self)
        self._name = None
        self.level = _checkLevel(level)
        self.formatter = None
        # Add the handler to the global _handlerList (for cleanup on shutdown)
        _addHandlerRef(self)
        self.createLock()

    def handle(self, record):
        rv = self.filter(record)   # Filter过滤，默认True
        if rv:
            self.acquire()
            try:
                # 需要注意的是此时self是自定制的handler对象，如果没有则是lastResort继承的StreamHandler
                self.emit(record)  # 最重要的方法，emit处理我们记录器里面放置的那些信息
            finally:
                self.release()
        return rv    

5 StreamHandler(Handler) 流处理

class StreamHandler(Handler):
    terminator = '\n'

    def __init__(self, stream=None):
        """
        Initialize the handler.

        If stream is not specified, sys.stderr is used.
        """
        Handler.__init__(self)
        if stream is None:
            stream = sys.stderr # 默认终端输出
        self.stream = stream

    def emit(self, record):
        try:
            msg = self.format(record)    # 格式化输出format处理就不展开阐述了
            stream = self.stream

            stream.write(msg)    # 发出信息
            stream.write(self.terminator)  # 打了个换行符 
            self.flush()   # 默认是sys.stderr，就是告诉终端立即输出
        except Exception:
            self.handleError(record)

6 FileHandler(Handler) 文件处理

class FileHandler(StreamHandler):
    """
    A handler class which writes formatted logging records to disk files.
    """
    def __init__(self, filename, mode='a', encoding=None, delay=False):
        filename = os.fspath(filename)
        self.baseFilename = os.path.abspath(filename)
        self.mode = mode
        self.encoding = encoding
        self.delay = delay
        if delay:
            Handler.__init__(self)
            self.stream = None
        else:
            StreamHandler.__init__(self, self._open())

    def emit(self, record):
        if self.stream is None:
            self.stream = self._open()  # 打开了一个文件流，但是并没有去写到文件

        # 判断是否还需要打印到终端
        StreamHandler.emit(self, record)

    
    def _open(self):
        """
        Open the current base file with the (original) mode and encoding.
        Return the resulting stream.
        """
        return open(self.baseFilename, self.mode, encoding=self.encoding)

"""关闭hanlder处理时候回调钩子"""
def shutdown(handlerList=_handlerList):
    for wr in reversed(handlerList[:]):
        #errors might occur, for example, if files are locked
        #we just ignore them if raiseExceptions is not set
        try:
            h = wr()
            if h:
                try:
                    h.acquire()
                    h.flush()  # 如果是文件就会触发文件对象的flush方法，一次性把日志内容都写入了
                    h.close()  # 清除流，关闭文件，清楚缓存区等操作
                except (OSError, ValueError):
                    pass
                finally:
                    h.release()
        except: # ignore everything, as we're shutting down
            if raiseExceptions:
                raise

二、流程图

python logging模块源码分析

标签：内容   技术   另一个   bst   hiera   高级   instance   parent   roc   

原文地址：https://www.cnblogs.com/zhangliang91/p/11920643.html