Python:日志模块-全局

我想知道如何实现一个全局记录器，可以在任何地方使用自己的设置:

我目前有一个自定义记录器类:

class customLogger(logging.Logger):
   ...

类与一些格式化程序和其他东西在一个单独的文件中。日志记录器可以自己完美地工作。

我将这个模块导入到我的主python文件中，并创建一个像这样的对象:

self.log = logModule.customLogger(arguments)

但是很明显，我不能从代码的其他部分访问这个对象。我用错方法了吗?有更好的方法吗?

使用logging.getLogger(name)创建一个命名的全局记录器

main.py

import log
logger = log.setup_custom_logger('root')
logger.debug('main message')
import submodule

log.py

import logging
def setup_custom_logger(name):
    formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)
    return logger

submodule.py

import logging
logger = logging.getLogger('root')
logger.debug('submodule message')

2011-10-01 20:08:40,049 - DEBUG - main - main message
2011-10-01 20:08:40,050 - DEBUG - submodule - submodule message

因为我还没有找到一个满意的答案，我想详细说明一下这个问题的答案，以便对Python标准库附带的logging库的工作原理和意图有一些深入的了解。

与OP(原始海报)的方法相反，库清楚地将记录器的接口和记录器本身的配置分开。

处理程序的配置是使用库的应用程序开发人员的特权。

这意味着你不应该创建一个自定义记录器类，并通过添加任何配置或其他方式在该类中配置记录器。

logging库引入了四个组件:记录器、处理程序、过滤器和格式化器。

记录器暴露了应用程序代码直接使用的接口。

处理程序将日志记录(由记录器创建)发送到适当的目的地。

过滤器为确定输出哪些日志记录提供了更细粒度的工具。

Formatters指定日志记录在最终输出中的布局。

一个常见的项目结构是这样的:

Project/
|-- .../
|   |-- ...
|
|-- project/
|   |-- package/
|   |   |-- __init__.py
|   |   |-- module.py
|   |   
|   |-- __init__.py
|   |-- project.py
|
|-- ...
|-- ...

在您的代码中(如module.py)，您引用模块的logger实例来记录特定级别的事件。

在命名记录器时使用的一个好习惯是在每个使用日志记录的模块中使用模块级记录器，命名如下:

logger = logging.getLogger(__name__)

特殊变量__name__引用模块的名称，根据应用程序的代码结构看起来类似project.package.module。

module.py(和任何其他类)基本上看起来像这样:

import logging
...
log = logging.getLogger(__name__)
class ModuleClass:
    def do_something(self):
        log.debug('do_something() has been called!')

每个模块中的记录器将把任何事件传播给父记录器，父记录器将信息传递给其附加的处理程序!与python包/模块结构类似，父日志记录器由命名空间使用"带点的模块名称"确定。这就是为什么用特殊的__name__变量初始化记录器是有意义的(在上面的示例中name匹配字符串"project.package.module")。

有两个选项可以全局配置日志记录器:

在project.py中实例化一个日志记录器，名称为__package__，在本例中等于"project"，因此是所有子模块的日志记录器的父日志记录器。只需要为这个记录器添加一个适当的处理程序和格式化程序。
在执行脚本(如main.py)中使用最顶层包的名称设置带有处理程序和格式化程序的记录器。

当开发一个使用日志记录的库时，您应该注意记录该库如何使用日志记录-例如，所使用的日志记录器的名称。

执行脚本，例如main.py，最终可能看起来像这样:

import logging
from project import App
def setup_logger():
    # create logger
    logger = logging.getLogger('project')
    logger.setLevel(logging.DEBUG)
    # create console handler and set level to debug
    ch = logging.StreamHandler()
    ch.setLevel(level)
    # create formatter
    formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s')
    # add formatter to ch
    ch.setFormatter(formatter)
    # add ch to logger
    logger.addHandler(ch)
if __name__ == '__main__' and __package__ is None:
     setup_logger()
     app = App()
     app.do_some_funny_stuff()

方法调用log.setLevel(...)指定记录器将处理但不一定输出的最低级别日志消息!它仅仅意味着只要消息的严重级别高于(或等于)所设置的严重级别，消息就会传递给处理程序。但是处理程序负责处理日志消息(例如通过打印或存储它)。

因此，logging库提供了一种结构化和模块化的方法，只需要根据需要进行开发。

日志文档

在日志模块中创建一个customLogger的实例，并将其作为单例使用——只使用导入的实例，而不是类。

python日志模块作为全局日志记录器已经足够好了，你可以简单地寻找这个:

main.py

import logging
logging.basicConfig(level = logging.DEBUG,format = '[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s')

把上面的代码放入你的执行脚本中，然后你可以在你的项目的任何地方使用相同的配置:

module.py

import logging
logger = logging.getLogger(__name__)
logger.info('hello world!')

对于更复杂的配置，您可以使用带有logging

的配置文件logging.conf

logging.config.fileConfig("logging.conf")

您可以在第一个句点之前向它传递一个带有公共子字符串的字符串。字符串中以句点(".")分隔的部分可以用于不同的类/模块/文件等。像这样(特别是logger = logging.getLogger(loggerName)部分):

def getLogger(name, logdir=LOGDIR_DEFAULT, level=logging.DEBUG, logformat=FORMAT):
    base = os.path.basename(__file__)
    loggerName = "%s.%s" % (base, name)
    logFileName = os.path.join(logdir, "%s.log" % loggerName)
    logger = logging.getLogger(loggerName)
    logger.setLevel(level)
    i = 0
    while os.path.exists(logFileName) and not os.access(logFileName, os.R_OK | os.W_OK):
        i += 1
        logFileName = "%s.%s.log" % (logFileName.replace(".log", ""), str(i).zfill((len(str(i)) + 1)))
    try:
        #fh = logging.FileHandler(logFileName)
        fh = RotatingFileHandler(filename=logFileName, mode="a", maxBytes=1310720, backupCount=50)
    except IOError, exc:
        errOut = "Unable to create/open log file "%s"." % logFileName
        if exc.errno is 13: # Permission denied exception
            errOut = "ERROR ** Permission Denied ** - %s" % errOut
        elif exc.errno is 2: # No such directory
            errOut = "ERROR ** No such directory "%s"** - %s" % (os.path.split(logFileName)[0], errOut)
        elif exc.errno is 24: # Too many open files
            errOut = "ERROR ** Too many open files ** - Check open file descriptors in /proc/<PID>/fd/ (PID: %s)" % os.getpid()
        else:
            errOut = "Unhandled Exception ** %s ** - %s" % (str(exc), errOut)
        raise LogException(errOut)
    else:
        formatter = logging.Formatter(logformat)
        fh.setLevel(level)
        fh.setFormatter(formatter)
        logger.addHandler(fh)
    return logger
class MainThread:
    def __init__(self, cfgdefaults, configdir, pidfile, logdir, test=False):
        self.logdir = logdir
        logLevel = logging.DEBUG
        logPrefix = "MainThread_TEST" if self.test else "MainThread"
        try:
            self.logger = getLogger(logPrefix, self.logdir, logLevel, FORMAT)
        except LogException, exc:
            sys.stderr.write("%sn" % exc)
            sys.stderr.flush()
            os._exit(0)
        else:
            self.logger.debug("-------------------- MainThread created.  Starting __init__() --------------------")
    def run(self):
        self.logger.debug("Initializing ReportThreads..")
        for (group, cfg) in self.config.items():
            self.logger.debug(" ------------------------------ GROUP '%s' CONFIG ------------------------------     " % group)
            for k2, v2 in cfg.items():
                self.logger.debug("%s <==> %s: %s" % (group, k2, v2))
            try:
                rt = ReportThread(self, group, cfg, self.logdir, self.test)
            except LogException, exc:
                sys.stderr.write("%sn" % exc)
                sys.stderr.flush()
                self.logger.exception("Exception when creating ReportThread (%s)" % group)
                logging.shutdown()
                os._exit(1)
            else:
                self.threads.append(rt)
        self.logger.debug("Threads initialized.. "%s"" % ", ".join([t.name for t in self.threads]))
        for t in self.threads:
            t.Start()
        if not self.test:
            self.loop()

class ReportThread:
    def __init__(self, mainThread, name, config, logdir, test):
        self.mainThread = mainThread
        self.name = name
        logLevel = logging.DEBUG
        self.logger = getLogger("MainThread%s.ReportThread_%s" % ("_TEST" if self.test else "", self.name), logdir, logLevel, FORMAT)
        self.logger.info("init database...")
        self.initDB()
        # etc....
if __name__ == "__main__":
    # .....
    MainThread(cfgdefaults=options.cfgdefaults, configdir=options.configdir, pidfile=options.pidfile, logdir=options.logdir, test=options.test)

相关内容

最新更新

热门标签：