Ausnahmebeschreibung und Stack-Trace, die eine Ausnahme verursacht haben, als String abrufen

Question

Ich habe eine Menge Beiträge über Stack Trace und Ausnahmen in Python gesehen. Aber habe nicht gefunden, was ich brauche.

Ich habe ein Stück Python 2.7-Code, der eine Ausnahme auslösen kann. Ich möchte es abfangen und einem String seine vollständige Beschreibung und den Stack-Trace, der den Fehler verursacht hat (einfach alles, was wir auf der Konsole sehen). Ich brauche diese Zeichenfolge, um sie in ein Textfeld in der GUI zu drucken.

Etwa so:

try:
    method_that_can_raise_an_exception(params)
except Exception as e:
    print_to_textbox(complete_exception_description(e))

Das Problem ist: Was ist die Funktion complete_exception_description ?

Answer 1

Wenn Sie Ihren Traceback in eine Liste von dict umwandeln möchten (für Python > 3.5):

from traceback import TracebackException

def list_traceback(exc_value: BaseException):
    result = list()

    # get previous fails, so errors are appended by order of execution
    if exc_value.__context__:
        result += list_traceback(exc_value.__context__)

    # convert Exception into TracebackException
    tbe = TracebackException.from_exception(exc_value)

    # get stacktrace (cascade methods calls)
    error_lines = list()
    for frame_summary in tbe.stack:
        summary_details = {
            'filename': frame_summary.filename,
            'method'  : frame_summary.name,
            'lineno'  : frame_summary.lineno,
            'code'    : frame_summary.line
        }
        error_lines.append(summary_details)

    # append error, by order of execution
    result.append({"error_lines": error_lines,
                   "type"       : tbe.exc_type.__name__,
                   "message"    : str(tbe)})

    return result

Dies wird (ein Beispiel für) das Ergebnis sein:

[
   {
      "error_lines": [
         {
            "filename": "/home/demo/file2.py",
            "method": "do_error_2",
            "lineno": 18,
            "code": "a=1/0"
         }
      ],
      "type": "ZeroDivisionError",
      "message": "division by zero"
   },
   {
      "error_lines": [
         {
            "filename": "/home/demo/file_main.py",
            "method": "demo2",
            "lineno": 50,
            "code": "file2.DEMO().do_error_2()"
         },
         {
            "filename": "/home/demo/file2.py",
            "method": "do_error_2",
            "lineno": 20,
            "code": "raise AssertionError(\"Raised inside the except, after division by zero\")"
         }
      ],
      "type": "AssertionError",
      "message": "Raised inside the except, after division by zero"
   }
]

Answer 2

Ich habe folgende Hilfsklasse definiert:

import traceback
class TracedExeptions(object):
    def __init__(self):
        pass
    def __enter__(self):
        pass

    def __exit__(self, etype, value, tb):
      if value :
        if not hasattr(value, 'traceString'):
          value.traceString = "\n".join(traceback.format_exception(etype, value, tb))
        return False
      return True

Das kann ich später so verwenden:

with TracedExeptions():
  #some-code-which-might-throw-any-exception

Und später kann es so konsumiert werden:

def log_err(ex):
  if hasattr(ex, 'traceString'):
    print("ERROR:{}".format(ex.traceString));
  else:
    print("ERROR:{}".format(ex));

(Hintergrund: Ich war frustriert wegen der Verwendung von Promise s zusammen mit Exception s, die leider Ausnahmen, die an einer Stelle ausgelöst wurden, an einen on_rejected-Handler an einer anderen Stelle weitergibt, so dass es schwierig ist, den Traceback von der ursprünglichen Stelle zu erhalten)