logging模块的使用

logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等.

1.Logger对象创建

很多程序都有记录日志的需求，并且日志中包含的信息既有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等

logging主要包括四部分：

• Loggers: 可供程序直接调用的接口，app通过调用提供的api来记录日志
• Handlers: 决定将日志记录分配至正确的目的地
• Filters:对日志信息进行过滤， 提供更细粒度的日志是否输出的判断
• Formatters: 制定最终记录打印的格式布局

1.1 loggers

logging.Logger对象扮演了三重角色:

• 它暴露给应用几个方法以便应用可以在运行时写log
• Logger对象按照log信息的严重程度或者根据filter对象来决定如何处理log信息(默认的过滤功能)
• logger还负责把log信息传送给相关的handlers

loggers对象是有父子关系的，当没有父logger对象时它的父对象是root，当拥有父对象时父子关系会被修正。举个例子，logging.getLogger("abc.xyz") 会创建两个logger对象，一个是abc父对象，一个是xyz子对象，同时abc没有父对象，所以它的父对象是root。但是实际上abc是一个占位对象（虚的日志对象），可以没有handler来处理日志。但是root不是占位对象，如果某一个日志对象打日志时，它的父对象会同时收到日志，所以有些使用者发现创建了一个logger对象时会打两遍日志，就是因为他创建的logger打了一遍日志，同时root对象也打了一遍日志。

1.2 Handlers

Handlers 将logger发过来的信息进行准确地分配，送往正确的地方。举个栗子，送往控制台或者文件或者both或者其他地方(进程管道之类的).它决定了每个日志的行为，是之后需要配置的重点区域.

每个Handler同样有一个日志级别，一个logger可以拥有多个handler也就是说logger可以根据不同的日志级别将日志传递给不同的handler.当然也可以相同的级别传递给多个handlers这就根据需求来灵活的设置了.

• Handlers种类

名称	位置	作用
StreamHandler	logging.StreamHandler	日志输出到流，可以是sys.stderr，sys.stdout或者文件
FileHandler	logging.FileHandler	日志输出到文件
BaseRotatingHandler	logging.handlers.BaseRotatingHandler	基本的日志回滚方式
RotatingHandler	logging.handlers.RotatingHandler	日志回滚方式，支持日志文件最大数量和日志文件回滚
TimeRotatingHandler	logging.handlers.TimeRotatingHandler	日志回滚方式，在一定时间区域内回滚日志文
SocketHandler	logging.handlers.SocketHandler	远程输出日志到TCP/IP sockets
DatagramHandler	logging.handlers.DatagramHandler	远程输出日志到UDP sockets
SMTPHandler	logging.handlers.SMTPHandler	远程输出日志到邮件地址
SysLogHandler	logging.handlers.SysLogHandler	日志输出到syslog
NTEventLogHandler	logging.handlers.NTEventLogHandler	远程输出日志到Windows NT/2000/XP的事件日志
MemoryHandler	logging.handlers.MemoryHandler	日志输出到内存中的指定buffer
HTTPHandler	logging.handlers.HTTPHandler	通过"GET"或者"POST"远程输出到HTTP服务器

• 日志回滚(RotatingFileHandler)
  如果用 FileHandler 写日志，文件的大小会随着时间推移而不断增大。最终有一天它会占满你所有的磁盘空间。为了避免这种情况出现，你可以在你的生成环境中使用 RotatingFileHandler 替代 FileHandler。

import logging
from logging.handlers import RotatingFileHandler
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
#定义一个RotatingFileHandler，最多备份3个日志文件，每个日志文件最大1K
rHandler = RotatingFileHandler("log.txt",maxBytes = 1*1024,backupCount = 3)
rHandler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
rHandler.setFormatter(formatter)
 
console = logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(formatter)
 
logger.addHandler(rHandler)
logger.addHandler(console)
 
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

1.3 Filters

Filters 提供了更细粒度的判断,来决定日志是否需要打印
原则上handler获得一个日志就必定会根据级别被统一处理,但是如果handler拥有一个Filter可以对日志进行额外的处理和判断
例如Filter能够对来自特定源的日志进行拦截or修改甚至修改其日志级别（修改后再进行级别判断）

logger和handler都可以安装filter甚至可以安装多个filter串联起来

1.4 Formatters

Formatters 指定了最终某条记录打印的格式布局。Formatter会将传递来的信息拼接成一条具体的字符串，默认情况下Format只会将信息%(messages)直接打印出来.Format中有一些自带的LogRecord属性可以使用，如下表格:

属性名称	格式	说明
name	%(name)s	日志的名称
asctime	%(asctime)s	可读时间，默认格式‘2003-07-08 16:49:45,896’，逗号之后是毫秒
filename	%(filename)s	文件名，pathname的一部分
pathname	%(pathname)s	文件的全路径名称
funcName	%(funcName)s	调用日志多对应的方法名
levelname	%(levelname)s	日志的等级
levelno	%(levelno)s	数字化的日志等级
lineno	%(lineno)d	被记录日志在源码中的行数
module	%(module)s	模块名
msecs	%(msecs)d	时间中的毫秒部分
process	%(process)d	进程的ID
processName	%(processName)s	进程的名称
thread	%(thread)d	线程的ID
threadName	%(threadName)s	线程的名称
relativeCreated	%(relativeCreated)d	日志被创建的相对时间，以毫秒为单位

一个Handler只能拥有一个Formatter 因此如果要实现多种格式的输出只能用多个Handler来实现

2 日志等级

可以给日志对象(Logger Instance)设置日志级别，低于该级别的日志消息将会被忽略，也可以给Hanlder设置日志级别，对于低于该级别的日志消息, Handler也会忽略。

• FATAL：致命错误
• CRITICAL：特别糟糕的事情，如内存耗尽、磁盘空间为空，一般很少使用
• ERROR：发生错误时，如IO操作失败或者连接问题
• WARNING：发生很重要的事件，但是并不是错误时，如用户登录密码错误
• INFO：处理请求或者状态变化等日常事务
• DEBUG：调试过程中使用DEBUG等级，如算法中每个循环的中间状态

3 常用函数

3.1 logging.basicConfig([**kwargs])

为日志模块配置基本信息,kwargs 支持如下几个关键字参数

• filename：指定日志文件名；
• filemode：和file函数意义相同，指定日志文件的打开模式，'w'或者'a'；
• format：指定输出的格式和内容，format可以输出很多有用的信息，
• datefmt：指定时间格式，同time.strftime()；
• level：设置日志级别，默认为logging.WARNNING；
• stream：指定将日志的输出流，可以指定输出到sys.stderr，sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略；　

import logging  

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(message)s')  

logging.debug('this is debug message')  
logging.info('this is info message')  
logging.warning('this is warning message')  

结果： 
2017-08-23 14:22:25,713 - root - this is debug message 
2017-08-23 14:22:25,713 - root - this is info message 
2017-08-23 14:22:25,714 - root - this is warning message 

3.2 logging.getLogger([name])

创建Logger对象。日志记录的工作主要由Logger对象来完成。在调用getLogger时要提供Logger的名称（注：多次使用相同名称来调用getLogger，返回的是同一个对象的引用。），Logger实例之间有层次关系，这些关系通过Logger名称来体现，如：

p = logging.getLogger(“root”)

c1 = logging.getLogger(“root.c1”)

c2 = logging.getLogger(“root.c2”)

例子中，p是父logger, c1,c2分别是p的子logger。c1, c2将继承p的设置。如果省略了name参数, getLogger将返回日志对象层次关系中的根Logger。

3.3 logger.setLevel(lvl)

设置日志的级别.对于低于该级别的日志消息将被忽略.

3.4 logging.getLevelName(lvl)

获取日志级别对应的名称

4 logging的使用

4.1 基本使用配置

import logging
from logging.handlers import TimedRotatingFileHandler
import os
from com_func.confread import config
from com_func.getpath import testpath

# 创建logger实例
logger = logging.getLogger(__name__)

# 设置输入日志等级
logger.setLevel(config.get("LOGGING", "level"))

# 设置日志输出格式
mat = "%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s"
logger_mat = logging.Formatter(mat)

# 输出日志到文件
handler_file = TimedRotatingFileHandler(os.path.join(testpath.LOG_DIR_PATH, config.get("FILE_NAME", "log")), when = "m", backupCount=3, encoding="utf-8")
handler_file.setLevel(config.get("LOGGING", "file_level"))
handler_file.setFormatter(logger_mat)

# 输出日志到控制台
handler_sh = logging.StreamHandler()
handler_sh.setLevel(config.get("LOGGING", "stream_level"))
handler_sh.setFormatter(logger_mat)

# 加载logging
logger.addHandler(handler_file)
logger.addHandler(handler_sh)

# 返回日志收集器
return logger

4.2 捕获traceback

python中的traceback模块用于记录异常信息，我们可以在logger中记录下traceback

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
handler = logging.FileHandler("log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
 
console = logging.StreamHandler()
console.setLevel(logging.INFO)
 
logger.addHandler(handler)
logger.addHandler(console)
 
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
try:
    open("sklearn.txt","rb")
except (SystemExit,KeyboardInterrupt):
    raise
except Exception:
    logger.error("Faild to open sklearn.txt from logger.error",exc_info = True)
 
logger.info("Finish")


也可以使用logger.exception(msg,_args)，它等价于logger.error(msg,exc_info = True,_args)
将logger.error("Faild to open sklearn.txt from logger.error",exc_info = True) 替换为
logger.exception("Failed to open sklearn.txt from logger.exception")

4.3 多模块使用logging

首先在主模块定义了logger'mainModule'，并对它进行了配置，就可以在解释器进程里面的其他地方通过getLogger('mainModule')得到的对象都是一样的，不需要重新配置，可以直接使用。定义的该logger的子logger，都可以共享父logger的定义和配置，所谓的父子logger是通过命名来识别，任意以'mainModule'开头的logger都是它的子logger，例如'mainModule.sub'。 实际开发一个application，首先可以通过logging配置文件编写好这个application所对应的配置，可以生成一个根logger，如'PythonAPP'，然后在主函数中通过fileConfig加载logging配置，接着在application的其他地方、不同的模块中，可以使用根logger的子logger，如'PythonAPP.Core'，'PythonAPP.Web'来进行log，而不需要反复的定义和配置各个模块的logger。

import logging
 
module_logger = logging.getLogger("mainModule.sub")
class SubModuleClass(object):
    def __init__(self):
        self.logger = logging.getLogger("mainModule.sub.module")
        self.logger.info("creating an instance in SubModuleClass")
    def doSomething(self):
        self.logger.info("do something in SubModule")
        a = []
        a.append(1)
        self.logger.debug("list a = " + str(a))
        self.logger.info("finish something in SubModuleClass")
 
def som_function():
    module_logger.info("call function some_function")

4.4 python logging 重复写日志问题

二次调用log的时候，根据getLogger(name)里的name获取同一个logger. 而这个logger里已经有了第一次你添加的handler，第二次调用又添加了一个handler. 所以，这个logger里有了两个同样的handler，以此类推，调用几次就会有几个handler.

解决办法：

• 每次创建不同name的logger，每次都是新logger，不会有添加多个handler的问题
• 每次记录完日志之后,用removeHandler()把这个logger里的handler移除掉.
• 在log方法里做判断,如果这个logger已有handler，则不再添加handler.
• 方法2一样,过把用pop把logger的handler列表中的handler移除.