我有一个小的Python项目，它具有以下结构 -
Project
-- pkg01
-- test01.py
-- pkg02
-- test02.py
-- logging.conf
我计划使用默认的日志记录模块将消息打印到标准输出和日志文件中。 要使用日志记录模块，需要进行一些初始化 -
import logging.config
logging.config.fileConfig('logging.conf')
logger = logging.getLogger('pyApp')
logger.info('testing')
目前，我在每个模块开始记录消息之前都执行此初始化。是否可能只在一个地方执行此初始化，以便所有项目中的日志记录都重用相同的设置？
最佳实践是，在每个模块中定义一个类似这样的记录器：
import logging
logger = logging.getLogger(__name__)
在模块的顶部附近，然后在模块中的其他代码中执行例如。
logger.debug('My message with %s', 'variable data')
如果您需要在模块内细分日志记录活动，请使用例如：
loggerA = logging.getLogger(__name__ + '.A')
loggerB = logging.getLogger(__name__ + '.B')
适当时记录到loggerA和loggerB。
在您的主程序中，示例如下：
def main():
"your program code"
if __name__ == '__main__':
import logging.config
logging.config.fileConfig('/path/to/logging.conf')
main()
def main():
import logging.config
logging.config.fileConfig('/path/to/logging.conf')
# your program code
if __name__ == '__main__':
main()
请参考这里进行多模块的日志记录，以及这里进行代码库模块的日志配置。
更新：在调用fileConfig()时，如果您使用的是Python 2.6或更高版本，请指定disable_existing_loggers=False（详见文档）。默认值为True以保持向后兼容性，这会导致fileConfig()禁用除显式命名配置中列出的所有现有记录器及其祖先之外的所有现有记录器。将该值设置为False后，现有记录器将保持不变。如果使用Python 2.7 / Python 3.2或更高版本，则可以考虑使用比fileConfig()更好的dictConfig() API，因为它可以更好地控制配置。
disable_existing_loggers标志，默认情况下为True，但可以设置为False。 - Vinay Sajip实际上，每个记录器都是父级包记录器的子记录器 (即 package.subpackage.module 继承自 package.subpackage)，因此您只需配置根记录器即可。这可以通过 logging.config.fileConfig（为记录器设置自己的配置）或 logging.basicConfig（设置根记录器）来实现。在入口模块 (__main__.py 或您想要运行的任何其他脚本，例如 main_script.py。也可以使用 __init__.py) 中设置日志。
使用 basicConfig:
# package/__main__.py
import logging
import sys
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
使用 fileConfig：
# package/__main__.py
import logging
import logging.config
logging.config.fileConfig('logging.conf')
然后使用以下方式创建每个记录器：
# package/submodule.py
# or
# package/subpackage/submodule.py
import logging
log = logging.getLogger(__name__)
log.info("Hello logging!")
更多信息请参见高级日志记录教程。
__main__.py中没有日志记录器（例如，我想在没有记录器的脚本中使用该模块），logging.getLogger(__name__)是否仍会对该模块进行某种形式的记录，还是会引发异常？ - Bill对我来说，使用一份日志库实例在多个模块中的简单方法如下：
import logging
logger = logging
logger.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)
from base_logger import logger
if __name__ == '__main__':
logger.info("This is an info message")
getLogger(__name__) 创建多个日志记录器了。使用这个回答，你只需要一行来导入/配置日志记录器。我还更喜欢在代码中使用 basicConfig 而不是 fileConfig(logging.conf)，因为你可以进行动态配置。另一种变化是，你可以删除 logger = logging 的别名，直接使用 logging.info()。或者你可以创建一个更短的别名比如 log=logging，来使用 log.info()。 - wisbucky我通常按以下方式执行。
使用一个名为 'log_conf.py' 的 Python 文件来配置我的日志为单例模式。
#-*-coding:utf-8-*-
import logging.config
def singleton(cls):
instances = {}
def get_instance():
if cls not in instances:
instances[cls] = cls()
return instances[cls]
return get_instance()
@singleton
class Logger():
def __init__(self):
logging.config.fileConfig('logging.conf')
self.logr = logging.getLogger('root')
在另一个模块中，只需导入 config。
from log_conf import Logger
Logger.logr.info("Hello World")
这是一个单例模式用于记录日志，简单高效。
提供另一种解决方案。
在我的模块的init.py文件中，我有类似下面的代码：
# mymodule/__init__.py
import logging
def get_module_logger(mod_name):
logger = logging.getLogger(mod_name)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
return logger
然后在每个模块中，我需要一个记录器，我这样做：
# mymodule/foo.py
from [modname] import get_module_logger
logger = get_module_logger(__name__)
当日志丢失时，您可以通过它们来自的模块区分它们的来源。
import logging
logger = logging.getLogger(__name__)
#my_module
import logging
logger = logging.getLogger(__name__)
def foo():
logger.info('Hi, foo')
class Bar(object):
def bar(self):
logger.info('Hi, bar')
在您的主模块中：
#main
import logging
# load my module - this now configures the logger
import my_module
# This will now disable the logger in my module by default, [see the docs][1]
logging.config.fileConfig('logging.ini')
my_module.foo()
bar = my_module.Bar()
bar.bar()
#my_module
import logging
logger = logging.getLogger(__name__)
def foo():
logging.getLogger(__name__).info('Hi, foo')
class Bar(object):
def bar(self):
logging.getLogger(__name__).info('Hi, bar')
disable_existing_loggers=True，我会非常惊讶地发现你忽略了这一点并仍然记录日志。 - DerWehmy_module中有很多日志记录语句，每次都写logging.getLogger(__name__).info("some message")非常繁琐。我认为这不是一个好的实践。 - jdhao我想分享我的解决方案（它基于日志菜谱和该主题的其他文章和建议）。然而，我花了很长时间才弄清楚为什么它没有立即按照我的期望工作。所以我创建了一个小测试项目来学习日志记录是如何工作的。
自从我搞清楚了之后，我想分享我的解决方案，也许它可以帮助某些人。
我知道我的一些代码可能不是最佳实践，但我还在学习。我把print()函数留在了里面，因为在日志记录未按预期工作时，我使用了它们。这些已在我的其他应用程序中删除。同时，我欢迎对代码或结构的任何部分提出反馈。
my_log_test 项目结构（从我正在工作的另一个项目中克隆/简化）
my_log_test
├── __init__.py
├── __main__.py
├── daemon.py
├── common
│ ├── my_logger.py
├── pkg1
│ ├── __init__.py
│ └── mod1.py
└── pkg2
├── __init__.py
└── mod2.py
需求
以下是我使用的组合中特别之处或我尚未明确提及的一些事项：
daemon.py，由__main__.py调用。mod1.py和mod2.py。basicConfig()或FileConfig()，而是像logging cookbook中那样保持不变。因此，这意味着我需要在daemon.py（始终）以及在模块mod1.py和mod2.py（仅在直接调用它们时）中初始化root日志记录器。
为了使多个模块中的初始化更加容易，我创建了my_logger.py，其中描述了logging cookbook中所述的内容。
我的错误
在该模块之前，我的错误在于使用logging.getLogger(__name__)（模块记录器）来初始化记录器，而不是使用logging.getLogger()（获取root记录器）。
第一个问题是，当从daemon.py调用时，记录器的命名空间设置为my_log_test.common.my_logger。因此，在mod1.py中具有“不匹配”命名空间my_log_test.pkg1.mod1的模块记录器无法连接到其他记录器，因此我将看不到来自mod1的日志输出。
第二个“问题”是，我的主程序在daemon.py中而不是在__main__.py中。但终究对我来说不是真正的问题，只是增加了命名空间的混乱程度。
可行解决方案
这是logging cookbook中的内容，但在一个单独的模块中。我还添加了一个logger_cleanup函数，我可以从daemon中调用该函数以删除x天之前的日志。
## my_logger.py
from datetime import datetime
import time
import os
## Init logging start
import logging
import logging.handlers
def logger_init():
print("print in my_logger.logger_init()")
print("print my_logger.py __name__: " +__name__)
path = "log/"
filename = "my_log_test.log"
## get logger
#logger = logging.getLogger(__name__) ## this was my mistake, to init a module logger here
logger = logging.getLogger() ## root logger
logger.setLevel(logging.INFO)
# File handler
logfilename = datetime.now().strftime("%Y%m%d_%H%M%S") + f"_{filename}"
file = logging.handlers.TimedRotatingFileHandler(f"{path}{logfilename}", when="midnight", interval=1)
#fileformat = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
fileformat = logging.Formatter("%(asctime)s [%(levelname)s]: %(name)s: %(message)s")
file.setLevel(logging.INFO)
file.setFormatter(fileformat)
# Stream handler
stream = logging.StreamHandler()
#streamformat = logging.Formatter("%(asctime)s [%(levelname)s:%(module)s] %(message)s")
streamformat = logging.Formatter("%(asctime)s [%(levelname)s]: %(name)s: %(message)s")
stream.setLevel(logging.INFO)
stream.setFormatter(streamformat)
# Adding all handlers to the logs
logger.addHandler(file)
logger.addHandler(stream)
def logger_cleanup(path, days_to_keep):
lclogger = logging.getLogger(__name__)
logpath = f"{path}"
now = time.time()
for filename in os.listdir(logpath):
filestamp = os.stat(os.path.join(logpath, filename)).st_mtime
filecompare = now - days_to_keep * 86400
if filestamp < filecompare:
lclogger.info("Delete old log " + filename)
try:
os.remove(os.path.join(logpath, filename))
except Exception as e:
lclogger.exception(e)
continue
要运行 deamon.py（通过__main__.py），请使用python3 -m my_log_test
## __main__.py
from my_log_test import daemon
if __name__ == '__main__':
print("print in __main__.py")
daemon.run()
要直接运行deamon.py，请使用python3 -m my_log_test.daemon
## daemon.py
from datetime import datetime
import time
import logging
import my_log_test.pkg1.mod1 as mod1
import my_log_test.pkg2.mod2 as mod2
## init ROOT logger from my_logger.logger_init()
from my_log_test.common.my_logger import logger_init
logger_init() ## init root logger
logger = logging.getLogger(__name__) ## module logger
def run():
print("print in daemon.run()")
print("print daemon.py __name__: " +__name__)
logger.info("Start daemon")
loop_count = 1
while True:
logger.info(f"loop_count: {loop_count}")
logger.info("do stuff from pkg1")
mod1.do1()
logger.info("finished stuff from pkg1")
logger.info("do stuff from pkg2")
mod2.do2()
logger.info("finished stuff from pkg2")
logger.info("Waiting a bit...")
time.sleep(30)
if __name__ == '__main__':
try:
print("print in daemon.py if __name__ == '__main__'")
logger.info("running daemon.py as main")
run()
except KeyboardInterrupt as e:
logger.info("Program aborted by user")
except Exception as e:
logger.info(e)
要直接运行mod1.py，请使用python3 -m my_log_test.pkg1.mod1
## mod1.py
import logging
# mod1_logger = logging.getLogger(__name__)
mod1_logger = logging.getLogger("my_log_test.daemon.pkg1.mod1") ## for testing, namespace set manually
def do1():
print("print in mod1.do1()")
print("print mod1.py __name__: " +__name__)
mod1_logger.info("Doing someting in pkg1.do1()")
if __name__ == '__main__':
## Also enable this pkg to be run directly while in development with
## python3 -m my_log_test.pkg1.mod1
## init root logger
from my_log_test.common.my_logger import logger_init
logger_init() ## init root logger
print("print in mod1.py if __name__ == '__main__'")
mod1_logger.info("Running mod1.py as main")
do1()
运行mod2.py（直接）使用python3 -m my_log_test.pkg2.mod2
## mod2.py
import logging
logger = logging.getLogger(__name__)
def do2():
print("print in pkg2.do2()")
print("print mod2.py __name__: " +__name__) # setting namespace through __name__
logger.info("Doing someting in pkg2.do2()")
if __name__ == '__main__':
## Also enable this pkg to be run directly while in development with
## python3 -m my_log_test.pkg2.mod2
## init root logger
from my_log_test.common.my_logger import logger_init
logger_init() ## init root logger
print("print in mod2.py if __name__ == '__main__'")
logger.info("Running mod2.py as main")
do2()
如果有所帮助，我很开心。也非常欢迎收到反馈！
def get_logger(name=None):
default = "__app__"
formatter = logging.Formatter('%(levelname)s: %(asctime)s %(funcName)s(%(lineno)d) -- %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
log_map = {"__app__": "app.log", "__basic_log__": "file1.log", "__advance_log__": "file2.log"}
if name:
logger = logging.getLogger(name)
else:
logger = logging.getLogger(default)
fh = logging.FileHandler(log_map[name])
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.setLevel(logging.DEBUG)
return logger
a=get_logger("__app___")
b=get_logger("__basic_log__")
a.info("Starting logging!")
b.debug("Debug Mode")
@Yarkee的解决方案看起来更好。我想再补充一些内容——
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances.keys():
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls]
class LoggerManager(object):
__metaclass__ = Singleton
_loggers = {}
def __init__(self, *args, **kwargs):
pass
@staticmethod
def getLogger(name=None):
if not name:
logging.basicConfig()
return logging.getLogger()
elif name not in LoggerManager._loggers.keys():
logging.basicConfig()
LoggerManager._loggers[name] = logging.getLogger(str(name))
return LoggerManager._loggers[name]
log=LoggerManager().getLogger("Hello")
log.setLevel(level=logging.DEBUG)
import logger, logging
def getlogger():
# logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
#ch = logging.StreamHandler()
ch = logging.FileHandler(r'log.txt')
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
return logger
from m_logger import getlogger
logger = getlogger()
logger.info('My mssg')
--debug 选项，并且希望基于此参数设置应用程序中 所有 记录器的记录级别... - The Godfatherget_logger(level=logging.INFO) 来返回某种单例，因此当它第一次从主应用程序调用时，它会使用适当的级别初始化记录器和处理程序，然后将相同的 logger 对象返回给所有其他方法。 - The Godfather
fileConfig，除非所有模块中都有if __name__ == '__main__'的逻辑。prost的回答对于库而言并不是最佳实践，尽管它可能适用于你——在库包中不应该配置日志记录，除非添加一个NullHandler。 - Vinay Sajippackage/__init__.py文件中。这通常不是你放置if __name__ == '__main__'代码的位置。此外，Prost 的示例似乎会在导入时无条件地调用配置代码，这对我来说看起来不太对。通常，日志配置代码应该在一个地方完成，并且不应该作为导入的副作用发生，除非你正在导入__main__。 - Vinay Sajip