Journalisation des exceptions non interceptées en Python

Comment provoquer la sortie d'exceptions non interceptées via le loggingmodule plutôt que vers stderr?

Je réalise que la meilleure façon de procéder serait:

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

Mais ma situation est telle que ce serait vraiment bien si elles logging.exception(...)étaient invoquées automatiquement chaque fois qu'une exception n'est pas interceptée.

Comme Ned l'a souligné, sys.excepthookest invoquée chaque fois qu'une exception est levée et non interceptée. L'implication pratique de ceci est que dans votre code, vous pouvez remplacer le comportement par défaut de sys.excepthookpour faire ce que vous voulez (y compris en utilisant logging.exception).

Comme exemple d'homme de paille:

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

Remplacer sys.excepthook:

>>> sys.excepthook = foo

Validez une erreur de syntaxe évidente (laissez de côté les deux points) et récupérez les informations d'erreur personnalisées:

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

Pour plus d'informations sur sys.excepthook, lisez la documentation .

Voici un petit exemple complet qui comprend également quelques autres astuces:

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")

• Ignorez KeyboardInterrupt pour qu'un programme python de console puisse quitter avec Ctrl + C.

• Fiez-vous entièrement au module de journalisation de python pour formater l'exception.

• Utilisez un enregistreur personnalisé avec un exemple de gestionnaire. Celui-ci modifie l'exception non gérée pour aller à stdout plutôt qu'à stderr, mais vous pouvez ajouter toutes sortes de gestionnaires dans ce même style à l'objet logger.

La méthode sys.excepthooksera appelée si une exception n'est pas interceptée: http://docs.python.org/library/sys.html#sys.excepthook

Lorsqu'une exception est déclenchée et non interceptée, l'interpréteur appelle sys.excepthook avec trois arguments, la classe d'exception, l'instance d'exception et un objet de trace. Dans une session interactive, cela se produit juste avant que le contrôle ne soit renvoyé à l'invite; dans un programme Python, cela se produit juste avant la fermeture du programme. La gestion de ces exceptions de niveau supérieur peut être personnalisée en attribuant une autre fonction à trois arguments à sys.excepthook.

Pourquoi pas:

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()

Voici la sortie avec sys.excepthookcomme vu ci-dessus:

$ 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

Voici la sortie avec le sys.excepthookcommentaire:

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

La seule différence est que le premier a ERROR:root:Unhandled exception:au début de la première ligne.

Pour construire sur la réponse de Jacinda, mais en utilisant un objet 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

Enveloppez votre appel d'entrée d'application dans un try...exceptbloc afin que vous puissiez attraper et enregistrer (et peut-être relancer) toutes les exceptions non interceptées. Par exemple au lieu de:

if __name__ == '__main__':
    main()

Faites ceci:

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

Vous pourriez peut-être faire quelque chose en haut d'un module qui redirige stderr vers un fichier, puis consigner ce fichier en bas

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() )

Bien que la réponse de @ gnu_lorien m'ait donné un bon point de départ, mon programme plante à la première exception.

Je suis venu avec une solution personnalisée (et / ou) améliorée, qui enregistre silencieusement les exceptions des fonctions qui sont décorées @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()

Pour répondre à la question de Mr.Zeus discutée dans la section commentaire de la réponse acceptée, j'utilise ceci pour enregistrer les exceptions non détectées dans une console interactive (testée avec PyCharm 2018-2019). J'ai découvert que sys.excepthookcela ne fonctionnait pas dans un shell python, alors j'ai regardé plus profondément et j'ai trouvé que je pourrais l'utiliser à la sys.exc_infoplace. Cependant, sys.exc_infone prend aucun argument contrairement à sys.excepthookcela prend 3 arguments.

Ici, j'utilise les deux sys.excepthooket sys.exc_infopour enregistrer les deux exceptions dans une console interactive et un script avec une fonction wrapper. Pour attacher une fonction hook aux deux fonctions, j'ai deux interfaces différentes selon que des arguments sont donnés ou non.

Voici le code:

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 configuration de la journalisation peut être trouvée dans la réponse de gnu_lorien.

Dans mon cas (en utilisant python 3) lors de l'utilisation de la réponse de @Jacinda, le contenu du retraçage n'a pas été imprimé. Au lieu de cela, il imprime juste l'objet lui - même: <traceback object at 0x7f90299b7b90>.

Au lieu de cela, je fais:

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