Registrazione delle eccezioni non rilevate in Python

In che modo si generano eccezioni non rilevate nell'output tramite il loggingmodulo anziché in stderr?

Mi rendo conto che il modo migliore per farlo sarebbe:

try:
    raise Exception, 'Throwing a boring exception'
except Exception, e:
    logging.exception(e)

Ma la mia situazione è tale che sarebbe davvero bello se logging.exception(...)venissero invocati automaticamente ogni volta che non viene rilevata un'eccezione.

Come sottolineato da Ned, sys.excepthookviene invocato ogni volta che viene sollevata e non rilevata un'eccezione. L'implicazione pratica di ciò è che nel tuo codice puoi sovrascrivere il comportamento predefinito di sys.excepthookfare quello che vuoi (incluso l'uso logging.exception).

Ad esempio un uomo di paglia:

>>> import sys
>>> def foo(exctype, value, tb):
...     print 'My Error Information'
...     print 'Type:', exctype
...     print 'Value:', value
...     print 'Traceback:', tb
... 

Ignora sys.excepthook:

>>> sys.excepthook = foo

Commette evidente errore di sintassi (tralascia i due punti) e recupera le informazioni di errore personalizzate:

>>> def bar(a, b)
My Error Information
Type: <type 'exceptions.SyntaxError'>
Value: invalid syntax (<stdin>, line 1)
Traceback: None

Per ulteriori informazioni sys.excepthook, leggi i documenti .

Ecco un piccolo esempio completo che include anche alcuni altri trucchi:

import sys
import logging
logger = logging.getLogger(__name__)
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)

def handle_exception(exc_type, exc_value, exc_traceback):
    if issubclass(exc_type, KeyboardInterrupt):
        sys.__excepthook__(exc_type, exc_value, exc_traceback)
        return

    logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))

sys.excepthook = handle_exception

if __name__ == "__main__":
    raise RuntimeError("Test unhandled")

• Ignora KeyboardInterrupt in modo che un programma python della console possa uscire con Ctrl + C.

• Affidati interamente al modulo di registrazione di Python per la formattazione dell'eccezione.

• Utilizzare un logger personalizzato con un gestore di esempio. Questa modifica l'eccezione non gestita per passare a stdout anziché a stderr, ma è possibile aggiungere tutti i tipi di gestori con lo stesso stile all'oggetto logger.

Il metodo sys.excepthookverrà invocato se non viene rilevata un'eccezione: http://docs.python.org/library/sys.html#sys.excepthook

Quando viene sollevata e non rilevata un'eccezione, l'interprete chiama sys.excepthook con tre argomenti, la classe di eccezione, l'istanza di eccezione e un oggetto traceback. In una sessione interattiva ciò accade poco prima che il controllo venga restituito al prompt; in un programma Python ciò accade poco prima della chiusura del programma. La gestione di tali eccezioni di livello superiore può essere personalizzata assegnando un'altra funzione a tre argomenti a sys.excepthook.

Perchè no:

import sys
import logging
import traceback

def log_except_hook(*exc_info):
    text = "".join(traceback.format_exception(*exc_info))
    logging.error("Unhandled exception: %s", text)

sys.excepthook = log_except_hook

None()

Ecco l'output con sys.excepthookcome visto sopra:

$ python tb.py
ERROR:root:Unhandled exception: Traceback (most recent call last):
  File "tb.py", line 11, in <module>
    None()
TypeError: 'NoneType' object is not callable

Ecco l'output con il sys.excepthookcommento:

$ python tb.py
Traceback (most recent call last):
  File "tb.py", line 11, in <module>
    None()
TypeError: 'NoneType' object is not callable

L'unica differenza è che il primo ha ERROR:root:Unhandled exception:all'inizio della prima riga.

Per costruire sulla risposta di Jacinda, ma usando un oggetto logger:

def catchException(logger, typ, value, traceback):
    logger.critical("My Error Information")
    logger.critical("Type: %s" % typ)
    logger.critical("Value: %s" % value)
    logger.critical("Traceback: %s" % traceback)

# Use a partially applied function
func = lambda typ, value, traceback: catchException(logger, typ, value, traceback)
sys.excepthook = func

Avvolgi la chiamata della tua app in un try...exceptblocco in modo da poter catturare e registrare (e forse ri-rilanciare) tutte le eccezioni non rilevate. Ad esempio invece di:

if __name__ == '__main__':
    main()

Fai questo:

if __name__ == '__main__':
    try:
        main()
    except Exception as e:
        logger.exception(e)
        raise

Forse potresti fare qualcosa nella parte superiore di un modulo che reindirizza stderr a un file e quindi registra quel file in fondo

sock = open('error.log', 'w')               
sys.stderr = sock

doSomething() #makes errors and they will log to error.log

logging.exception(open('error.log', 'r').read() )

Sebbene la risposta di @ gnu_lorien mi abbia dato un buon punto di partenza, il mio programma si blocca alla prima eccezione.

Sono arrivato con una soluzione personalizzata (e / o) migliorata, che registra in silenzio Eccezioni di funzioni decorate @handle_error.

import logging

__author__ = 'ahmed'
logging.basicConfig(filename='error.log', level=logging.DEBUG)


def handle_exception(exc_type, exc_value, exc_traceback):
    import sys
    if issubclass(exc_type, KeyboardInterrupt):
        sys.__excepthook__(exc_type, exc_value, exc_traceback)
        return
    logging.critical(exc_value.message, exc_info=(exc_type, exc_value, exc_traceback))


def handle_error(func):
    import sys

    def __inner(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception, e:
            exc_type, exc_value, exc_tb = sys.exc_info()
            handle_exception(exc_type, exc_value, exc_tb)
        finally:
            print(e.message)
    return __inner


@handle_error
def main():
    raise RuntimeError("RuntimeError")


if __name__ == "__main__":
    for _ in xrange(1, 20):
        main()

Per rispondere alla domanda di Mr.Zeus discussa nella sezione commenti della risposta accettata, la utilizzo per registrare eccezioni non rilevate in una console interattiva (testata con PyCharm 2018-2019). Ho scoperto sys.excepthookche non funziona in una shell Python, quindi ho guardato più in profondità e ho scoperto che avrei potuto usare sys.exc_infoinvece. Tuttavia, sys.exc_infonon accetta argomenti a differenza di sys.excepthookquello che accetta 3 argomenti.

Qui, uso entrambi sys.excepthooke sys.exc_infoper registrare entrambe le eccezioni in una console interattiva e uno script con una funzione wrapper. Per associare una funzione hook ad entrambe le funzioni, ho due interfacce diverse a seconda che vengano forniti argomenti o meno.

Ecco il codice:

def log_exception(exctype, value, traceback):
    logger.error("Uncaught exception occurred!",
                 exc_info=(exctype, value, traceback))


def attach_hook(hook_func, run_func):
    def inner(*args, **kwargs):
        if not (args or kwargs):
            # This condition is for sys.exc_info
            local_args = run_func()
            hook_func(*local_args)
        else:
            # This condition is for sys.excepthook
            hook_func(*args, **kwargs)
        return run_func(*args, **kwargs)
    return inner


sys.exc_info = attach_hook(log_exception, sys.exc_info)
sys.excepthook = attach_hook(log_exception, sys.excepthook)

La configurazione della registrazione può essere trovata nella risposta di gnu_lorien.

Nel mio caso (utilizzo python 3) quando si utilizza la risposta di @Jacinda, il contenuto del traceback non è stato stampato. Invece, si limita a stampare l'oggetto stesso: <traceback object at 0x7f90299b7b90>.

Invece faccio:

import sys
import logging
import traceback

def custom_excepthook(exc_type, exc_value, exc_traceback):
    # Do not print exception when user cancels the program
    if issubclass(exc_type, KeyboardInterrupt):
        sys.__excepthook__(exc_type, exc_value, exc_traceback)
        return

    logging.error("An uncaught exception occurred:")
    logging.error("Type: %s", exc_type)
    logging.error("Value: %s", exc_value)

    if exc_traceback:
        format_exception = traceback.format_tb(exc_traceback)
        for line in format_exception:
            logging.error(repr(line))

sys.excepthook = custom_excepthook