Exception traceback est masqué si pas relancé immédiatement

J'ai un morceau de code similaire à ceci:

import sys

def func1():
    func2()

def func2():
    raise Exception('test error')

def main():
    err = None

    try:
        func1()
    except:
        err = sys.exc_info()[1]
        pass

    # some extra processing, involving checking err details (if err is not None)

    # need to re-raise err so caller can do its own handling
    if err:
        raise err

if __name__ == '__main__':
    main()

Quand func2 soulève une exception, je reçois la suite de l'exī:

Traceback (most recent call last):
  File "err_test.py", line 25, in <module>
    main()
  File "err_test.py", line 22, in main
    raise err
Exception: test error

D'ici, je ne vois pas où l'exception est à venir à partir de. L'original de trace est perdue.

Comment puis-je préserver original assurer la traçabilité et de la relancer? Je veux voir quelque chose de similaire à ceci:

Traceback (most recent call last):
  File "err_test.py", line 26, in <module>
    main()
  File "err_test.py", line 13, in main
    func1()
  File "err_test.py", line 4, in func1
    func2()
  File "err_test.py", line 7, in func2
    raise Exception('test error')
Exception: test error
InformationsquelleAutor parxier | 2011-01-28
  1. 110

    Un vide raise soulève la dernière exception.

    # need to re-raise err so caller can do its own handling
if err:
    raise

    Si vous utilisez raise something Python a aucun moyen de savoir si something était une exception juste pris avant, ou une nouvelle exception avec une nouvelle trace de la pile. C'est pourquoi il y a le vide raise qui conserve la trace de la pile.

    Référence ici

    • La peine de mentionner que cela ne fonctionne pas en Python 3.
    • "Ce" en yprez commentaire signifie "vide lever après avoir quitté le bloc except." Le nu "relance" ne travaillent dans Python 3 (mais seulement à l'intérieur du bloc except.)
    InformationsquelleAutor Jochen Ritzel
  2. 66

    Il est possible de modifier et renvoyer une exception:

    Si aucune des expressions sont présents, raise re-soulève la dernière exception que
    a été active dans le champ d'application actuel. Si aucune exception n'est active dans le
    champ d'application actuel, un TypeError exception est levée, indiquant que c'est
    un message d'erreur (si en cours d'exécution en vertu de l'INACTIVITÉ, un Queue.Empty exception est levée
    au lieu de cela).

    Sinon, raise évalue les expressions d'obtenir trois objets, à l'aide
    None que la valeur de omis expressions. Les deux premiers objets sont
    utilisé pour déterminer le type et la valeur de l'exception.

    Si un troisième objet est présent et pas None, il doit être un traceback
    objet (voir La section le type standard de la hiérarchie), et il est
    substituer à la place de l'emplacement actuel comme le lieu où le
    exception s'est produite. Si le troisième objet est présent et pas un traceback
    objet ou None, un TypeError exception est levée.

    Les trois-expression
    formulaire de raise est utile de re-lever une exception de manière transparente dans un
    except clause, mais raise avec aucune expression doit être préférée si l'
    l'exception à être re-soulevé a été le plus récemment active exception
    dans le champ d'application actuel.

    Donc, si vous voulez modifier l'exception et le renvoyer, vous pouvez le faire:

    try:
    buggy_code_which_throws_exception()
except Exception as e:
    raise Exception, "The code is buggy: %s" % e, sys.exc_info()[2]
    • Intéressant. La accepté de répondre à des poignées de l'OP de cas d'utilisation, mieux que cela, mais ce qui est intéressant aussi, de manière plus générale la réponse. Je ne vois pas beaucoup l'utilité, bien que depuis le traceback est vraiment trompeur si vous le prenez, par exemple, un ValueError et élever une RuntimeError (vous ne pouvez pas le voir, alors, qu'un ValueError a jamais participé), et le seul cas que j'ai rencontré personnellement, quand j'ai voulu conserver la traçabilité en amont, mais faire quelque chose de plus complexe que de simplement raise sans arguments ont été les cas où je voulais soulever une exception d'un type différent.
    • J'ai utilisé ce renvoyer la même exception avec un message différent, y compris plus de détails sur les conditions qui ont causé l'exception, qui sont disponibles à l'extérieur de la portée, mais pas l'intérieur.
    • Il y a parfois de très bonnes raisons pour utiliser ce système à trois une forme d'expression de relance. Votre réponse m'a aidé à écrire un décorateur qui encapsule les tests d'intégration et sur l'échec prend une capture d'écran. Et puis la soulève l'original de l'échec d'assertion. Le problème étant que le traceback était de se ridiculiser par un try/extraits dans la capture d'écran code. Alors merci!
    • est-il un moyen de le faire avec Python 2 et Python 3 compatible? Je reçois SyntaxError en Python 3.
    • href="https://pythonhosted.org/six/#six.reraise" >six.sur-relancer(exc_type, exc_value, exc_traceback=Aucun)
    InformationsquelleAutor qris
  3. 7

    Vous pouvez obtenir beaucoup d'informations sur l'exception via le sys.exc_info() avec le traceback module

    essayer l'extension suivante de votre code.

    import sys
import traceback

def func1():
    func2()

def func2():
    raise Exception('test error')

def main():

    try:
        func1()
    except:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        # Do your verification using exc_value and exc_traceback

        print "*** print_exception:"
        traceback.print_exception(exc_type, exc_value, exc_traceback,
                                  limit=3, file=sys.stdout)

if __name__ == '__main__':
    main()

    Ce serait d'imprimer, similaire à ce que tu voulais.

    *** print_exception:
Traceback (most recent call last):
  File "err_test.py", line 14, in main
    func1()
  File "err_test.py", line 5, in func1
    func2()
  File "err_test.py", line 8, in func2
    raise Exception('test error')
Exception: test error
    • Non, je ne veux pas l'imprimer dans le main(). Je veux la relancer avec l'original assurer la traçabilité et de laisser l'appelant de main() à y faire face (par exemple, l'ignorer, de l'impression à la console, pour les sauvegarder dans la base de données, etc). Jochen la solution a fonctionné.
    • Ce serait la meilleure réponse pour Python3, si vous modifiez le print à quelque chose comme raise exc_type.with_traceback(exc_value, exc_traceback)
    InformationsquelleAutor Senthil Kumaran
  4. 5

    Tandis que @Jochen réponse qui fonctionne bien dans le cas simple, il n'est pas capable de traiter des cas plus complexes, où vous n'êtes pas directement de capture et de renvoi, mais pour une raison particulière compte tenu de l'exception comme un objet, et souhaitez re-lancer dans un tout nouveau contexte (par exemple, si vous avez besoin de la traiter dans un autre processus).

    Dans ce cas, je propose ce qui suit:

    1. d'obtenir l'original exc_info
    2. format de l'original message d'erreur, avec la trace de la pile
    3. lancer une nouvelle exception avec ce message d'erreur complet (trace de la pile incl.) intégré

    Avant de faire cela, de définir un nouveau type d'exception qui vous permettra de renvoyer à plus tard...

    class ChildTaskException(Exception):
    pass

    Dans le code fautif...

    import sys
import traceback

try:
    # do something dangerous
except:
    error_type, error, tb = sys.exc_info()
    error_lines = traceback.format_exception(error_type, error, tb)
    error_msg = ''.join(error_lines)
    # for example, if you are doing multiprocessing, you might want to send this to another process via a pipe
    connection.send(error_msg)

    Renvoyer...

    # again, a multiprocessing example of receiving that message through a pipe
error_msg = pcon.recv()
raise ChildTaskException(error_msg)
    InformationsquelleAutor tvt173
  5. 2

    Votre fonction principale doit ressembler à ceci:

    def main():
    try:
        func1()
    except Exception, err:
        # error processing
        raise

    C'est la façon standard de manipulation (et sur-relancer) des erreurs. Voici une codepad démonstration.

    • J'ai le sentiment que except Exception, err: peut être contourné avec l'ancienne raise "bad exception" façon de lever des exceptions
    • ensuite, utilisez except object, err
    • Ce n'est pas différent de err = sys.exc_info()[1]. De toute façon, le point principal a été ré-augmenter err à l'extérieur de except bloc sans perdre d'origine traceback. Jochen la solution a fonctionné.
    InformationsquelleAutor Gabi Purcaru