笔记-python-module-logging.循环日志、多进程日志

1. logging循环日志

循环日志分为按大小切分和按时间切分，对应实现类如下。

1.1. RotatingFileHandler

常规文件回滚，需要指定文件名，encoding,maxBytes

如果maxbytes=0 或backupcount=0情况下不回滚，也就是只写到一个文件中。

新的日志永远写入filename.log，当它满的时候会将filename.log改名为filename.log.1或其它附加值；

def _set_file_handler(self, level=None):
    file_name = os.path.join(LOG_PATH, '{}.log'.format(self.name))
    file_handler =
RotatingFileHandler(file_name,
                                       maxBytes=5000,
                                       backupCount=5,
                                       encoding='utf-8')
    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)

1.2.
TimeRotatingFileHandler

def _set_time_rotating_handler(self, level=None):
    file_name = os.path.join(LOG_PATH, '{}.log'.format(self.name))
    time_handler =
logging.handlers.TimedRotatingFileHandler(file_name,

when='h',

               interval=1,

backupCount=5)
    if not level:
        time_handler.setLevel(self.level)
    else:
        time_handler.setLevel(level)
    formatter = logging.Formatter('%(asctime)s
%(filename)s [line:%(lineno)d] %(levelname)s %(message)s')
    time_handler.setFormatter(formatter)
    time_handler.suffix = "%Y-%m-%d_%H-%M-%S.log"
    self.addHandler(time_handler)

需要注意的就是suffix的书写

1.3.
总结

有几个坑要注意：

尽量使用Logger(__name__)，一般情况下是不需要日志传递的
使用getLogger返回的实际是一个日志树
logger实例初始化的propagate属性是true，即向父辈传递消息。而且消息是直接传递给handler。

2.
multiprocessing and logging

logging 是线程安全的，handler 内部使用了
threading.RLock() 来保证同一时间只有一个线程能够输出。

但是，在使用 logging.FileHandler 时，多进程同时写一个日志文件是不支持的。

测试时发现多个进程写同一个文件是可以的，但部分文档说如果写长字符串时会出问题，测试写5000个字符的日志没问题，更长未确认。

在日志回滚时一定会出问题。

多进程写日志回滚的代码如下：

t
= self.rolloverAt - self.interval

if self.utc:

timeTuple = time.gmtime(t)

else:

timeTuple = time.localtime(t)

dfn = self.baseFilename + "." + time.strftime(self.suffix,
timeTuple)

if os.path.exists(dfn):

os.remove(dfn)

os.rename(self.baseFilename, dfn)

关键是在每个进程在过了rotate时间点之后写第一条日志时，都会执行这个doRollover，判断文件是否存在，如果存在则删除，改名，往新的.log中写入，等多个进程都做一遍后，前一周期的日志完全删除，本周期的日志也会有部分被删除。

术语一点的讲，就是在对文件操作时，没有对多进程进行一些约束。

解决办法：

解决文件重名问题：

既然问题是文件重名，那么就不让文件有重名，实际就是每个进程各写一个文件；有两种方法：

1）在文件名中加入pid，问题是老的pid不会被自动删除，无法自维护，不过可以通过定时任务检查并删除。

2）另一种方法是使用进程name做为logger名，在创建进程时给出不同的name，这样不会出现上面的问题；

不让文件重名的好处是可以单独追踪每个进程的日志，坏处是日志不集中。

建议使用这种方式，写日志有两种情况：

1-一般情况下每个进程是负责不同任务的，分开记录便于查找；

2-如果确实需要多个进程执行一样的任务，这时在查找日志记录时是比较麻烦的，不确定在哪个日志文件中，但考虑到工程效率，本方法也是可行的。

使用独立进程接收并写日志，logging提供了sockethandler；
改写logging的日志回滚类代码，不太喜欢，每次还得注意环境问题。
进程锁，效率问题，方法可行，但考虑各种因素，一般不会用。

2.1.
一些问题：windows下多进程异常

报错：The "freeze_support()"
line can be omitted if the program is not going to be

原因及解决方法：

应该是在其它的子进程
里又开了进程，

把创建进程部分放到 if __name__ == ‘__main__’下即可

例：

if __name__ == '__main__':
    p = Process(target=func, name='my_process')
    p.daemon = True
    p.start()
    p.join()
    print('process
execute complete.')

3.
Logging.getLogger

getLogger是模块级的函数，实际是调用manager.getLogger()

def getLogger(name=None):

"""

Return a logger with the specified name, creating it if necessary.

If no name is specified, return the root logger.

"""

if name:

return Logger.manager.getLogger(name)

else:

return root

继续：manager.getLogger()

def
getLogger(self, name):

"""

Get a logger with the specified name (channel name), creating it

if it doesn't yet exist. This name is a dot-separated hierarchical

name, such as "a", "a.b", "a.b.c" or
similar.

If a PlaceHolder existed for the specified name [i.e. the logger

didn't exist but a child of it did], replace it with the created

logger and fix up the parent/child references which pointed to the

placeholder to now point to the logger.

"""

rv = None

if not isinstance(name, str):

raise TypeError('A logger name must be a string')

_acquireLock()

try:

if name in self.loggerDict:

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)

rv.manager = self

self.loggerDict[name] = rv

self._fixupParents(rv)

finally:

_releaseLock()

return rv

logging通过manager.loggerDict维护了一个logger列表，实现了相同名称返回同一个loogger。

如果logger名不存在，则创建一个新的：

rv = (self.loggerClass or
_loggerClass)(name)

基本等同于logger(name)

另外一点是logger的继承关系，是通过下面两个方法实现的

self._fixupChildren(ph, rv)

self._fixupParents(rv)