可以根据消息日志级别修改 Python 的日志记录格式吗？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1343227/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Can Python's logging format be modified depending on the message log level?
提问by bedwyr
I'm using Python's loggingmechanism to print output to the screen. I could do this with print statements, but I want to allow a finer-tuned granularity for the user to disable certain types of output. I like the format printed for errors, but would prefer a simpler format when the output level is "info."
我正在使用 Python 的logging机制将输出打印到屏幕上。我可以用打印语句来做到这一点，但我希望允许用户更精细地调整粒度以禁用某些类型的输出。我喜欢为错误打印的格式，但当输出级别为“信息”时更喜欢更简单的格式。
For example:
例如：
logger.error("Running cmd failed")
logger.info("Running cmd passed")
In this example, I would like the format of the error to be printed differently:
在这个例子中，我希望以不同的方式打印错误的格式：
# error Aug 27, 2009 - ERROR: Running cmd failed # info Running cmd passed
# error Aug 27, 2009 - ERROR: Running cmd failed # info Running cmd passed
Is it possible to have different formats for different log levels without having multiple logging objects? I'd prefer to do this without modifying the logger once it's created since there are a high number of if/else statements to determine how the output should be logged.
在没有多个日志对象的情况下，是否可以为不同的日志级别使用不同的格式？我更喜欢在创建记录器后不修改它的情况下执行此操作，因为有大量 if/else 语句来确定应如何记录输出。
采纳答案by Vinay Sajip
Yes, you can do this by having a custom Formatterclass:
是的，您可以通过自定义Formatter类来做到这一点：
class MyFormatter(logging.Formatter):
def format(self, record):
#compute s according to record.levelno
#for example, by setting self._fmt
#according to the levelno, then calling
#the superclass to do the actual formatting
return s
Then attach a MyFormatterinstance to your handlers.
然后将一个MyFormatter实例附加到您的处理程序。
回答by JS.
I just ran into this issue and had trouble filling in the "holes" left in the above example. Here's a more complete, working version that I used. Hopefully this helps someone:
我刚刚遇到了这个问题，但在填补上面例子中留下的“漏洞”时遇到了麻烦。这是我使用的更完整的工作版本。希望这有助于某人：
# Custom formatter
class MyFormatter(logging.Formatter):
err_fmt = "ERROR: %(msg)s"
dbg_fmt = "DBG: %(module)s: %(lineno)d: %(msg)s"
info_fmt = "%(msg)s"
def __init__(self, fmt="%(levelno)s: %(msg)s"):
logging.Formatter.__init__(self, fmt)
def format(self, record):
# Save the original format configured by the user
# when the logger formatter was instantiated
format_orig = self._fmt
# Replace the original format with one customized by logging level
if record.levelno == logging.DEBUG:
self._fmt = MyFormatter.dbg_fmt
elif record.levelno == logging.INFO:
self._fmt = MyFormatter.info_fmt
elif record.levelno == logging.ERROR:
self._fmt = MyFormatter.err_fmt
# Call the original formatter class to do the grunt work
result = logging.Formatter.format(self, record)
# Restore the original format configured by the user
self._fmt = format_orig
return result
Edit:
编辑：
Compliments of Halloleo, here's an example of how to use the above in your script:
赞美 Halloleo，以下是如何在脚本中使用上述内容的示例：
fmt = MyFormatter()
hdlr = logging.StreamHandler(sys.stdout)
hdlr.setFormatter(fmt)
logging.root.addHandler(hdlr)
logging.root.setLevel(DEBUG)
Edit 2:
编辑2：
Python3 logging has changed a bit. See herefor a Python3 approach.
Python3 日志记录发生了一些变化。有关Python3 方法，请参见此处。
回答by estani
And again like JS answer but more compact.
再次像 JS 答案，但更紧凑。
class SpecialFormatter(logging.Formatter):
FORMATS = {logging.DEBUG :"DBG: %(module)s: %(lineno)d: %(message)s",
logging.ERROR : "ERROR: %(message)s",
logging.INFO : "%(message)s",
'DEFAULT' : "%(levelname)s: %(message)s"}
def format(self, record):
self._fmt = self.FORMATS.get(record.levelno, self.FORMATS['DEFAULT'])
return logging.Formatter.format(self, record)
hdlr = logging.StreamHandler(sys.stderr)
hdlr.setFormatter(SpecialFormatter())
logging.root.addHandler(hdlr)
logging.root.setLevel(logging.INFO)
回答by Evpok
This is an adaptation of estani's answerto the new implementation of logging.Formatterwhich now relies on formatting styles. Mine relies on '{'style format, but it can be adapted. Could be refined to be more general and allow selection of formatting style and custom messages as arguments to __init__, too.
这是对estani对logging.Formatter现在依赖于格式样式的新实现的回答的改编。我的依赖于'{'样式格式，但可以进行调整。可以改进为更通用，并允许选择格式样式和自定义消息作为 的参数__init__。
class SpecialFormatter(logging.Formatter):
FORMATS = {logging.DEBUG : logging._STYLES['{']("{module} DEBUG: {lineno}: {message}"),
logging.ERROR : logging._STYLES['{']("{module} ERROR: {message}"),
logging.INFO : logging._STYLES['{']("{module}: {message}"),
'DEFAULT' : logging._STYLES['{']("{module}: {message}")}
def format(self, record):
# Ugly. Should be better
self._style = self.FORMATS.get(record.levelno, self.FORMATS['DEFAULT'])
return logging.Formatter.format(self, record)
hdlr = logging.StreamHandler(sys.stderr)
hdlr.setFormatter(SpecialFormatter())
logging.root.addHandler(hdlr)
logging.root.setLevel(logging.INFO)
回答by Joris
Instead of relying on styles or internal fields, you could also create a Formatter that delegates to other formatters depending on record.levelno (or other criteria). This is a slightly cleaner solution in my humble opinion. Code below should work for any python version >= 2.7:
除了依赖样式或内部字段，您还可以创建一个 Formatter，根据 record.levelno（或其他标准）委托给其他格式化程序。以我的拙见，这是一个稍微干净的解决方案。下面的代码应该适用于任何 >= 2.7 的 python 版本：
The simple way would look something like this:
简单的方法看起来像这样：
class MyFormatter(logging.Formatter):
default_fmt = logging.Formatter('%(levelname)s in %(name)s: %(message)s')
info_fmt = logging.Formatter('%(message)s')
def format(self, record):
if record.levelno == logging.INFO:
return self.info_fmt.format(record)
else:
return self.default_fmt.format(record)
But you could make it more generic:
但是你可以让它更通用：
class VarFormatter(logging.Formatter):
default_formatter = logging.Formatter('%(levelname)s in %(name)s: %(message)s')
def __init__(self, formats):
""" formats is a dict { loglevel : logformat } """
self.formatters = {}
for loglevel in formats:
self.formatters[loglevel] = logging.Formatter(formats[loglevel])
def format(self, record):
formatter = self.formatters.get(record.levelno, self.default_formatter)
return formatter.format(record)
I used a dict as input here, but obviously you could also use tuples, **kwargs, whatever floats your boat. This would then be used like:
我在这里使用 dict 作为输入，但显然你也可以使用元组，**kwargs，任何漂浮在你船上的东西。这将被用作：
formatter = VarFormatter({logging.INFO: '[%(message)s]',
logging.WARNING: 'warning: %(message)s'})
<... attach formatter to logger ...>
回答by user1837990
The above solution works with 3.3.3 release. However with 3.3.4 you get the following error.
上述解决方案适用于 3.3.3 版本。但是，在 3.3.4 中，您会收到以下错误。
FORMATS = { logging.DEBUG : logging._STYLES['{']("{module} DEBUG: {lineno}: {message}"),
TypeError: 'tuple' object is not callable
类型错误：“元组”对象不可调用
After some searching around in the logging class Lib\logging__init__.py I found that a data structure has changed from 3.3.3 to 3.3.4 that causes the issue
在日志类 Lib\logging__init__.py 中搜索后，我发现数据结构已从 3.3.3 更改为 3.3.4 导致问题
3.3.3
3.3.3
_STYLES = {
'%': PercentStyle,
'{': StrFormatStyle,
'$': StringTemplateStyle
}
3.3.4
3.3.4
_STYLES = {
'%': (PercentStyle, BASIC_FORMAT),
'{': (StrFormatStyle, '{levelname}:{name}:{message} AA'),
'$': (StringTemplateStyle, '${levelname}:${name}:${message} BB'),
}
The updated solution is therefore
因此，更新的解决方案是
class SpecialFormatter(logging.Formatter):
FORMATS = {logging.DEBUG : logging._STYLES['{'][0]("{module} DEBUG: {lineno}: {message}"),
logging.ERROR : logging._STYLES['{'][0]("{module} ERROR: {message}"),
logging.INFO : logging._STYLES['{'][0]("{module}: {message}"),
'DEFAULT' : logging._STYLES['{'][0]("{module}: {message}")}
def format(self, record):
# Ugly. Should be better
self._style = self.FORMATS.get(record.levelno, self.FORMATS['DEFAULT'])
return logging.Formatter.format(self, record)
回答by JDiMatteo
If you are just looking to skip formatting certain levels, you can do something simpler than the other answers like the following:
如果您只是想跳过某些级别的格式设置，您可以做一些比其他答案更简单的事情，如下所示：
class FormatterNotFormattingInfo(logging.Formatter):
def __init__(self, fmt = '%(levelname)s:%(message)s'):
logging.Formatter.__init__(self, fmt)
def format(self, record):
if record.levelno == logging.INFO:
return record.getMessage()
return logging.Formatter.format(self, record)
This also has the advantage of working before and after the 3.2 release by not using internal variables like self._fmt nor self._style.
这还具有在 3.2 版本之前和之后工作的优点，即不使用 self._fmt 或 self._style 等内部变量。
回答by Sergey Pleshakov
ONE WAY OF DOING THIS
一种方法
Define a class
定义一个类
import logging
class CustomFormatter(logging.Formatter):
"""Logging Formatter to add colors and count warning / errors"""
grey = "\x1b[38;21m"
yellow = "\x1b[33;21m"
red = "\x1b[31;21m"
bold_red = "\x1b[31;1m"
reset = "\x1b[0m"
format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
FORMATS = {
logging.DEBUG: grey + format + reset,
logging.INFO: grey + format + reset,
logging.WARNING: yellow + format + reset,
logging.ERROR: red + format + reset,
logging.CRITICAL: bold_red + format + reset
}
def format(self, record):
log_fmt = self.FORMATS.get(record.levelno)
formatter = logging.Formatter(log_fmt)
return formatter.format(record)
Instantiate logger
实例化记录器
# create logger with 'spam_application'
logger = logging.getLogger("My_app")
logger.setLevel(logging.DEBUG)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(CustomFormatter())
logger.addHandler(ch)
And use!
并使用！
logger.debug("debug message")
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
Result
结果
