如何记录带有调试信息的 Python 错误？

Question

我使用 logging.error 将 Python 异常消息打印到日志文件：

import logging
try:
    1/0
except ZeroDivisionError as e:
    logging.error(e)  # ERROR:root:division by zero

是否可以打印有关异常和生成异常的代码的更多详细信息，而不仅仅是异常字符串？像行号或堆栈跟踪这样的东西会很棒。

Answer 1

logger.exception 将输出堆栈跟踪与错误消息一起。

例如：

import logging
try:
    1/0
except ZeroDivisionError:
    logging.exception("message")

输出：

ERROR:root:message
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: integer division or modulo by zero

@Paulo Cheque 注释，“请注意，在 Python 3 中，您必须调用 logging.exception 方法就在 except 部分中，如果您在任意位置调用此方法，您可能会收到一个奇怪的异常。”

Answer 2

使用 exc_info 选项可能会更好，允许您选择错误级别（如果您使用 exception，它将始终处于 error 级别）：

try:
    # do something here
except Exception as e:
    logging.critical(e, exc_info=True)  # log exception info at CRITICAL log level

Answer 3

SiggyF 的答案 没有显示的关于 logging.exception 的一个好处是，您可以传入一个任意消息，并且日志记录仍将显示包含所有异常详细信息的完整回溯：

import logging
try:
    1/0
except ZeroDivisionError:
    logging.exception("Deliberate divide by zero traceback")

默认（在最新版本中）日志记录行为仅将错误打印到 sys.stderr ，它看起来像这样：

>>> import logging
>>> try:
...     1/0
... except ZeroDivisionError:
...     logging.exception("Deliberate divide by zero traceback")
... 
ERROR:root:Deliberate divide by zero traceback
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: integer division or modulo by zero

Answer 4

引用

如果您的应用程序以其他方式进行日志记录（不使用logging模块）怎么办？

现在，可以在这里使用traceback。

import traceback

def log_traceback(ex, ex_traceback=None):
    if ex_traceback is None:
        ex_traceback = ex.__traceback__
    tb_lines = [ line.rstrip('\n') for line in
                 traceback.format_exception(ex.__class__, ex, ex_traceback)]
    exception_logger.log(tb_lines)

• 在Python 2中使用它：

  <前><代码>尝试：
  # 你的函数调用在这里
  除了异常例如：
  _、_、ex_traceback = sys.exc_info()
  log_traceback（前，ex_traceback）

• 在Python 3中使用它：

  <前><代码>尝试：
  x = get_number()
  除了异常例如：
  log_traceback(前)

Answer 5

您可以毫无异常地记录堆栈跟踪。

https://docs.python.org/3/library/logging .html#logging.Logger.debug

第二个可选关键字参数是 stack_info，默认为 False。如果为 true，则堆栈信息将添加到日志记录消息中，包括实际的日志记录调用。请注意，这与通过指定 exc_info 显示的堆栈信息不同：前者是从堆栈底部到当前线程中的日志记录调用的堆栈帧，而后者是有关已展开的堆栈帧的信息，发生异常后，同时搜索异常处理程序。

例子：

>>> import logging
>>> logging.basicConfig(level=logging.DEBUG)
>>> logging.getLogger().info('This prints the stack', stack_info=True)
INFO:root:This prints the stack
Stack (most recent call last):
  File "<stdin>", line 1, in <module>
>>>

Answer 6

如果您使用纯日志 - 所有日志记录都应符合以下规则：一条记录 = 一行。遵循此规则，您可以使用 grep 和其他工具来处理日志文件。

但回溯信息是多行的。所以我的答案是上面的 zangw 提出的解决方案的扩展版本。问题是回溯行可能有 \n 内部，所以我们需要做额外的工作来摆脱这个行结尾：

import logging


logger = logging.getLogger('your_logger_here')

def log_app_error(e: BaseException, level=logging.ERROR) -> None:
    e_traceback = traceback.format_exception(e.__class__, e, e.__traceback__)
    traceback_lines = []
    for line in [line.rstrip('\n') for line in e_traceback]:
        traceback_lines.extend(line.splitlines())
    logger.log(level, traceback_lines.__str__())

之后（当你分析你的日志时）你可以复制/ 从日志文件中粘贴所需的回溯行并执行以下操作：

ex_traceback = ['line 1', 'line 2', ...]
for line in ex_traceback:
    print(line)

利润！

Answer 7

这个答案是建立在上述优秀答案的基础上的。

在大多数应用程序中，您不会直接调用logging.exception(e)。您很可能已经为您的应用程序或模块定义了一个特定的自定义记录器，如下所示：

# Set the name of the app or module
my_logger = logging.getLogger('NEM Sequencer')
# Set the log level
my_logger.setLevel(logging.INFO)

# Let's say we want to be fancy and log to a graylog2 log server
graylog_handler = graypy.GELFHandler('some_server_ip', 12201)
graylog_handler.setLevel(logging.INFO)
my_logger.addHandler(graylog_handler)

在这种情况下，只需使用记录器来调用异常（e），如下所示：

try:
    1/0
except ZeroDivisionError, e:
    my_logger.exception(e)

Answer 8

如果“调试信息”是指引发异常时出现的值，那么 logging.exception(...) 将无济于事。因此，您需要一个工具来自动记录所有变量值以及回溯行。

开箱即用，你会得到类似“

2020-03-30 18:24:31 main ERROR   File "./temp.py", line 13, in get_ratio
2020-03-30 18:24:31 main ERROR     return height / width
2020-03-30 18:24:31 main ERROR       height = 300
2020-03-30 18:24:31 main ERROR       width = 0
2020-03-30 18:24:31 main ERROR builtins.ZeroDivisionError: division by zero

看看一些 pypi 工具，我命名为：

• tbvaccine
• traceback-with-variables
• better-exceptions

其中一些会给你漂亮的崩溃消息：

但您可能会在 pypi 上找到更多信息

Answer 9

从 Python 3.5 开始，可以在

try:
    1/0
except Exception as ex:
    logging.error("Error occurred", exc_info = ex)

日志记录函数中显式指定异常：logging.exception 函数仍然有效，但必须仅在 except 块内调用，并且不允许指定日志级别。

Answer 10

一点装饰器处理（非常松散地受到 Maybe monad 和提升的启发）。您可以安全地删除 Python 3.6 类型注释并使用较旧的消息格式样式。

fallible.py

from functools import wraps
from typing import Callable, TypeVar, Optional
import logging


A = TypeVar('A')


def fallible(*exceptions, logger=None) \
        -> Callable[[Callable[..., A]], Callable[..., Optional[A]]]:
    """
    :param exceptions: a list of exceptions to catch
    :param logger: pass a custom logger; None means the default logger, 
                   False disables logging altogether.
    """
    def fwrap(f: Callable[..., A]) -> Callable[..., Optional[A]]:

        @wraps(f)
        def wrapped(*args, **kwargs):
            try:
                return f(*args, **kwargs)
            except exceptions:
                message = f'called {f} with *args={args} and **kwargs={kwargs}'
                if logger:
                    logger.exception(message)
                if logger is None:
                    logging.exception(message)
                return None

        return wrapped

    return fwrap

演示：

In [1] from fallible import fallible

In [2]: @fallible(ArithmeticError)
    ...: def div(a, b):
    ...:     return a / b
    ...: 
    ...: 

In [3]: div(1, 2)
Out[3]: 0.5

In [4]: res = div(1, 0)
ERROR:root:called <function div at 0x10d3c6ae8> with *args=(1, 0) and **kwargs={}
Traceback (most recent call last):
  File "/Users/user/fallible.py", line 17, in wrapped
    return f(*args, **kwargs)
  File "<ipython-input-17-e056bd886b5c>", line 3, in div
    return a / b

In [5]: repr(res)
'None'

您还可以修改此解决方案，以从 except 部分返回比 None 更有意义的内容（或者甚至使解决方案通用，通过在 fallible 的参数中指定此返回值）。

Answer 11

在您的日志记录模块（如果是自定义模块）中，只需启用 stack_info。

api_logger.exceptionLog("*Input your Custom error message*",stack_info=True)

Answer 12

如果您查看此代码示例（适用于Python 2和3），您会请参阅下面的函数定义，它可以提取

• 整个堆栈跟踪的方法
• 行号代码
• 上下文
• 文件路径

，无论是否存在异常：

def sentry_friendly_trace(get_last_exception=True):
    try:
        current_call = list(map(frame_trans, traceback.extract_stack()))
        alert_frame = current_call[-4]
        before_call = current_call[:-4]

        err_type, err, tb = sys.exc_info() if get_last_exception else (None, None, None)
        after_call = [alert_frame] if err_type is None else extract_all_sentry_frames_from_exception(tb)

        return before_call + after_call, err, alert_frame
    except:
        return None, None, None

当然，这个函数取决于上面链接的整个要点，特别是 extract_all_sentry_frames_from_exception() 和 frame_trans()，但异常信息提取总共不到 60 行左右。

希望有帮助！

Answer 13

我将所有功能包装在我的定制设计的记录器中：

import json
import timeit
import traceback
import sys
import unidecode

def main_writer(f,argument):
  try:
    f.write(str(argument))
  except UnicodeEncodeError:
    f.write(unidecode.unidecode(argument))


def logger(*argv,logfile="log.txt",singleLine = False):
  """
  Writes Logs to LogFile
  """
  with open(logfile, 'a+') as f:
    for arg in argv:
      if arg == "{}":
        continue
      if type(arg) == dict and len(arg)!=0:
        json_object = json.dumps(arg, indent=4, default=str)
        f.write(str(json_object))
        f.flush()
        """
        for key,val in arg.items():
          f.write(str(key) + " : "+ str(val))
          f.flush()
        """
      elif type(arg) == list and len(arg)!=0:
        for each in arg:
          main_writer(f,each)
          f.write("\n")
          f.flush()
      else:
        main_writer(f,arg)
        f.flush()
      if singleLine==False:
        f.write("\n")
    if singleLine==True:
      f.write("\n")

def tryFunc(func, func_name=None, *args, **kwargs):
  """
  Time for Successfull Runs
  Exception Traceback for Unsuccessful Runs
  """
  stack = traceback.extract_stack()
  filename, codeline, funcName, text = stack[-2]
  func_name = func.__name__ if func_name is None else func_name # sys._getframe().f_code.co_name # func.__name__
  start = timeit.default_timer()
  x = None
  try:
    x = func(*args, **kwargs)
    stop = timeit.default_timer()
    # logger("Time to Run {} : {}".format(func_name, stop - start))
  except Exception as e:
    logger("Exception Occurred for {} :".format(func_name))
    logger("Basic Error Info :",e)
    logger("Full Error TraceBack :")
    # logger(e.message, e.args)
    logger(traceback.format_exc())
  return x

def bad_func():
  return 'a'+ 7

if __name__ == '__main__':
    logger(234)
    logger([1,2,3])
    logger(['a','b','c'])
    logger({'a':7,'b':8,'c':9})
    tryFunc(bad_func)

Answer 14

执行此操作的最佳且最小的库是 loguru，它显示内置的回溯并提供调试信息：

import sys
from loguru import logger
logger.add(sys.stdout, level="TRACE")

try:
    a = 1/0
except Exception as err:
    logger.exception(str(err), backtrace=True, diagnose=True)

输出：

2023-08-09 10:46:53.669 | ERROR    | __main__:<module>:8 - division by zero
Traceback (most recent call last):

> File "new.py", line 6, in <module>
    a = 1/0

ZeroDivisionError: division by zero

Answer 15

我的方法是创建一个上下文管理器，用于记录和引发异常：

import logging
from contextlib import AbstractContextManager


class LogError(AbstractContextManager):

    def __init__(self, logger=None):
        self.logger = logger.name if isinstance(logger, logging.Logger) else logger

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_value is not None:
            logging.getLogger(self.logger).exception(exc_value)


with LogError():
    1/0

您可以将记录器名称或记录器实例传递给 LogError()。默认情况下，它将使用基本记录器（通过将 None 传递给logging.getLogger）。
人们还可以简单地添加一个开关来引发错误或只是记录错误。

Answer 16

如果您可以处理额外的依赖关系，则使用twisted.log，您不必显式记录错误，并且它还会将整个回溯和时间返回到文件或流。

Answer 17

一种干净的方法是使用 format_exc() 然后解析输出以获取相关部分：

from traceback import format_exc

try:
    1/0
except Exception:
    print 'the relevant part is: '+format_exc().split('\n')[-2]

问候