How do you cause uncaught exceptions to output via the logging module rather than to stderr?
I realize the best way to do this would be:
try: raise Exception, 'Throwing a boring exception' except Exception, e: logging.exception(e) But my situation is such that it would be really nice if logging.exception(...) were invoked automatically whenever an exception isn't caught.
Here's a complete small example that also includes a few other tricks:
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") Ignore KeyboardInterrupt so a console python program can exit with Ctrl + C.
Rely entirely on python's logging module for formatting the exception.
Use a custom logger with an example handler. This one changes the unhandled exception to go to stdout rather than stderr, but you could add all sorts of handlers in this same style to the logger object.
logger.critical() inside the excepthook handler, since an uncaught exception is pretty critical I would say.
As Ned pointed out, sys.excepthook is invoked every time an exception is raised and uncaught. The practical implication of this is that in your code you can override the default behavior of sys.excepthook to do whatever you want (including using logging.exception).
As a straw man example:
import sys def foo(exctype, value, tb): print('My Error Information') print('Type:', exctype) print('Value:', value) print('Traceback:', tb) Override sys.excepthook:
>>> sys.excepthook = foo Commit obvious syntax error (leave out the colon) and get back custom error information:
>>> def bar(a, b) My Error Information Type: <type 'exceptions.SyntaxError'> Value: invalid syntax (<stdin>, line 1) Traceback: None For more information about sys.excepthook, read the docs.
type as a function argument, although IDEs will complain about hiding the global type (much like using var self = this in Javascript). It doesn't really matter unless you need to access the type object inside your function, in which case you can use type_ as the argument instead.
sys.excepthook is NOT called when an exception is "raised". It is called when the program is going to terminate due to an uncaught exception, which cannot happen more than once.
Why not:
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() Here is the output with sys.excepthook as seen above:
$ 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 Here is the output with the sys.excepthook commented out:
$ python tb.py Traceback (most recent call last): File "tb.py", line 11, in <module> None() TypeError: 'NoneType' object is not callable The only difference is that the former has ERROR:root:Unhandled exception: at the beginning of the first line.
sys.stderr.
The method sys.excepthook will be invoked if an exception is uncaught: http://docs.python.org/library/sys.html#sys.excepthook
When an exception is raised and uncaught, the interpreter calls sys.excepthook with three arguments, the exception class, exception instance, and a traceback object. In an interactive session this happens just before control is returned to the prompt; in a Python program this happens just before the program exits. The handling of such top-level exceptions can be customized by assigning another three-argument function to sys.excepthook.
type on the instance?
sys.excepthook?In my case (using python 3) when using @Jacinda 's answer the content of the traceback was not printed. Instead, it just prints the object itself: <traceback object at 0x7f90299b7b90>.
Instead I do:
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 
traceback,format(tb(exc_traceback) helped me resolve my missing understanding of the difference between traceback the handler and exc_traceback the object. I was trying to use the handler's methods on the object like exc_traceback.format_tb which was obviously not working. Once I knew how to work with the handler and object, it opens up the universe of working with tracebacks! Thanks!
To build on Jacinda's answer, but using a logger object:
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 
functools.partial() instead of lambda. See: docs.python.org/2/library/functools.html#functools.partial
Wrap your app entry call in a try...except block so you'll be able to catch and log (and perhaps re-raise) all uncaught exceptions. E.g. instead of:
if __name__ == '__main__': main() Do this:
if __name__ == '__main__': try: main() except Exception as e: logger.exception(e) raise 
Although @gnu_lorien's answer gave me good starting point, my program crashes on first exception.
I came with a customised (and/or) improved solution, which silently logs Exceptions of functions that are decorated with @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() To answer the question from Mr.Zeus discussed in the comment section of the accepted answer, I use this to log uncaught exceptions in an interactive console (tested with PyCharm 2018-2019). I found out sys.excepthook does not work in a python shell so I looked deeper and found that I could use sys.exc_info instead. However, sys.exc_info takes no arguments unlike sys.excepthook that takes 3 arguments.
Here, I use both sys.excepthook and sys.exc_info to log both exceptions in an interactive console and a script with a wrapper function. To attach a hook function to both functions, I have two different interfaces depending if arguments are given or not.
Here's the 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) The logging setup can be found in gnu_lorien's answer.
Maybe you could do something at the top of a module that redirects stderr to a file, and then logg that file at the bottom
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() ) 