Extraer información de rastreo de un objeto de excepción

Dado un objeto de excepción (de origen desconocido), ¿hay forma de obtener su rastreo? Tengo un código como este:

def stuff():
   try:
       .....
       return useful
   except Exception as e:
       return e

result = stuff()
if isinstance(result, Exception):
    result.traceback <-- How?

¿Cómo puedo extraer el rastreo del objeto Exception una vez que lo tengo?

La respuesta a esta pregunta depende de la versión de Python que esté usando.

En Python 3

Es simple: las excepciones vienen equipadas con un __traceback__atributo que contiene el rastreo. Este atributo también se puede escribir y se puede configurar convenientemente utilizando el with_tracebackmétodo de excepciones:

raise Exception("foo occurred").with_traceback(tracebackobj)

Estas características se describen mínimamente como parte de la raisedocumentación.

Todo el crédito por esta parte de la respuesta debe ir a Vyctor, quien primero publicó esta información . Lo incluyo aquí solo porque esta respuesta está atascada en la parte superior y Python 3 se está volviendo más común.

En Python 2

Es fastidiosamente complejo. El problema con los tracebacks es que tienen referencias a marcos de pila, y los marcos de pila tienen referencias a los tracebacks que tienen referencias a marcos de pila que tienen referencias a ... ya se hace una idea. Esto causa problemas al recolector de basura. (Gracias a ecatmur por señalar esto primero).

La buena forma de resolver esto sería romper quirúrgicamente el ciclo después de salir de la exceptcláusula, que es lo que hace Python 3. La solución Python 2 es mucho más fea: se le proporciona una función ad-hoc sys.exc_info(), que solo funciona dentro de la except cláusula . Devuelve una tupla que contiene la excepción, el tipo de excepción y el rastreo de cualquier excepción que se esté manejando actualmente.

Entonces, si está dentro de la exceptcláusula, puede usar la salida de sys.exc_info()junto con el tracebackmódulo para hacer varias cosas útiles:

>>> import sys, traceback
>>> def raise_exception():
...     try:
...         raise Exception
...     except Exception:
...         ex_type, ex, tb = sys.exc_info()
...         traceback.print_tb(tb)
...     finally:
...         del tb
... 
>>> raise_exception()
  File "<stdin>", line 3, in raise_exception

Pero como indica su edición, está intentando obtener el rastreo que se habría impreso si su excepción no se hubiera manejado, después de que ya se haya manejado. Esa es una pregunta mucho más difícil. Desafortunadamente, sys.exc_inforegresa (None, None, None)cuando no se maneja ninguna excepción. Otros sysatributos relacionados tampoco ayudan. sys.exc_tracebackestá en desuso y no está definido cuando no se maneja ninguna excepción; sys.last_tracebackparece perfecto, pero parece que solo se define durante las sesiones interactivas.

Si puede controlar cómo se genera la excepción, es posible que pueda usar inspectuna excepción personalizada para almacenar parte de la información. Pero no estoy del todo seguro de cómo funcionaría.

A decir verdad, detectar y devolver una excepción es algo inusual. Esto podría ser una señal de que necesita refactorizar de todos modos.

Desde Python 3.0 ^{[PEP 3109],} la clase incorporada Exceptiontiene un __traceback__atributo que contiene un traceback object(con Python 3.2.3):

>>> try:
...     raise Exception()
... except Exception as e:
...     tb = e.__traceback__
...
>>> tb
<traceback object at 0x00000000022A9208>

El problema es que después de buscar en Google__traceback__ por un tiempo, encontré solo algunos artículos, pero ninguno de ellos describe si debería (no) usarlos o por qué __traceback__.

Sin embargo, la documentación de Python 3raise dice que:

Normalmente, un objeto de rastreo se crea automáticamente cuando se genera una excepción y se le adjunta como __traceback__atributo, que se puede escribir.

Así que supongo que está destinado a ser utilizado.

Una forma de obtener el rastreo como una cadena de un objeto de excepción en Python 3:

import traceback

# `e` is an exception object that you get from somewhere
traceback_str = ''.join(traceback.format_tb(e.__traceback__))

traceback.format_tb(...)devuelve una lista de cadenas. ''.join(...)los une. Para obtener más referencias, visite: https://docs.python.org/3/library/traceback.html#traceback.format_tb

Por otro lado, si realmente desea obtener el rastreo completo como lo vería impreso en su terminal, desea esto:

>>> try:
...     print(1/0)
... except Exception as e:
...     exc = e
...
>>> exc
ZeroDivisionError('division by zero')
>>> tb_str = traceback.format_exception(etype=type(exc), value=exc, tb=exc.__traceback__)
>>> tb_str
['Traceback (most recent call last):\n', '  File "<stdin>", line 2, in <module>\n', 'ZeroDivisionError: division by zero\n']
>>> print("".join(tb_str))
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

Si usa las format_tbrespuestas anteriores sugieren que obtendrá menos información:

>>> tb_str = "".join(traceback.format_tb(exc.__traceback__))
>>> print("".join(tb_str))
  File "<stdin>", line 2, in <module>

Hay una muy buena razón por la que el rastreo no se almacena en la excepción; Debido a que el rastreo contiene referencias a los locales de su pila, esto daría como resultado una referencia circular y una fuga de memoria (temporal) hasta que el GC circular entre en funcionamiento (es por eso que nunca debe almacenar el rastreo en una variable local ).

Lo único en lo que puedo pensar es que montes stufflos globales de parche para que cuando crea que está detectando, en realidad esté detectando Exceptionun tipo especializado y la excepción se propague a ti como llamador:

module_containing_stuff.Exception = type("BogusException", (Exception,), {})
try:
    stuff()
except Exception:
    import sys
    print sys.exc_info()