def _log_all_uncaught_exceptions(exc_type, exc_value, exc_traceback):
"""Log all uncaught exceptions in non-interactive mode.
All python exceptions are handled by function, stored in
``sys.excepthook.`` By rewriting the default implementation, we
can modify handling of all uncaught exceptions.
Warning: modified behaviour (logging of all uncaught exceptions)
applies only when runing in non-interactive mode.
"""
# ignore KeyboardInterrupt
if not issubclass(exc_type, KeyboardInterrupt):
ROOT_LOGGER.error("", exc_info=(exc_type, exc_value, exc_traceback))
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
# Rewrite the default implementation os sys.excepthook to log all
# uncaught exceptions:
python类__excepthook__()的实例源码
def _exception_hook(exc_type, exc_value, exc_traceback):
if exc_type.__name__ == 'StreamerError':
node = exc_value.node
error = exc_value.error
# node.graph.draw(attention=node)
logger.error('Error occured when running streamers. See graph')
exc_type = type(error)
exc_value = error
elif exc_type.__name__ == 'StreamerConnError':
node1 = exc_value.src_node
node2 = exc_value.tgt_node
error = exc_value.error
# node1.graph.draw(attention=[node1, node2])
logger.error('Error occured when running streamers. See graph')
exc_type = type(error)
exc_value = error
sys.__excepthook__(exc_type, exc_value, exc_traceback)
def octario_excepthook(exc_type, exc_value, exc_traceback):
"""exception hook that sends OctarioException to log and other
exceptions to stderr (default excepthook)
"""
from octario.lib.exceptions import OctarioException
# sends full exception with trace to log
if not isinstance(exc_value, OctarioException):
return sys.__excepthook__(exc_type, exc_value, exc_traceback)
if LOG.getEffectiveLevel() <= logging.DEBUG:
formated_exception = "".join(
traceback.format_exception(exc_type, exc_value, exc_traceback))
LOG.error(formated_exception + exc_value.message)
else:
LOG.error(exc_value.message)
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print(traceback.print_tb(tb))
sys.exit(1)
else:
print(value)
sys.exit(1)
return excepthook
def main():
# type: () -> typing.Any
"""Parse the command line options and launch the requested command.
If the command is 'help' then print the help message for the subcommand; if
no subcommand is given, print the standard help message.
"""
colorama.init(wrap=six.PY3)
doc = usage.get_primary_command_usage()
allow_subcommands = '<command>' in doc
args = docopt(doc, version=settings.version,
options_first=allow_subcommands)
if sys.excepthook is sys.__excepthook__:
sys.excepthook = log.excepthook
try:
log.enable_logging(log.get_log_level(args))
default_args = sys.argv[2 if args.get('<command>') else 1:]
if (args.get('<command>') == 'help' and
None not in settings.subcommands):
subcommand = next(iter(args.get('<args>', default_args)), None)
return usage.get_help_usage(subcommand)
argv = [args.get('<command>')] + args.get('<args>', default_args)
return _run_command(argv)
except exc.InvalidCliValueError as e:
return str(e)
def paste_traceback(exc_type, exc, tb):
"""
This is a traceback handler that knows how to paste to the pastebin.
Should only be used in sys.excepthook.
"""
sys.__excepthook__(exc_type, exc, tb)
from yt.extern.six.moves import StringIO, xmlrpc_client
p = xmlrpc_client.ServerProxy(
"http://paste.yt-project.org/xmlrpc/",
allow_none=True)
s = StringIO()
traceback.print_exception(exc_type, exc, tb, file=s)
s = s.getvalue()
ret = p.pastes.newPaste('pytb', s, None, '', '', True)
print()
print("Traceback pasted to http://paste.yt-project.org/show/%s" % (ret))
print()
def test_unhandled(self):
# Check for sensible reporting of unhandled exceptions
for exc_type in (ValueError, BrokenStrException):
try:
exc = exc_type("test message")
# The following line is included in the traceback report:
raise exc
except exc_type:
with captured_stderr() as stderr:
sys.__excepthook__(*sys.exc_info())
report = stderr.getvalue()
self.assertIn("test_exceptions.py", report)
self.assertIn("raise exc", report)
self.assertIn(exc_type.__name__, report)
if exc_type is BrokenStrException:
self.assertIn("<exception str() failed>", report)
else:
self.assertIn("test message", report)
self.assertTrue(report.endswith("\n"))
def test_original_excepthook(self):
savestderr = sys.stderr
err = cStringIO.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError, exc:
eh(*sys.exc_info())
sys.stderr = savestderr
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_unhandled(self):
# Check for sensible reporting of unhandled exceptions
for exc_type in (ValueError, BrokenStrException):
try:
exc = exc_type("test message")
# The following line is included in the traceback report:
raise exc
except exc_type:
with captured_stderr() as stderr:
sys.__excepthook__(*sys.exc_info())
report = stderr.getvalue()
self.assertIn("test_exceptions.py", report)
self.assertIn("raise exc", report)
self.assertIn(exc_type.__name__, report)
if exc_type is BrokenStrException:
self.assertIn("<exception str() failed>", report)
else:
self.assertIn("test message", report)
self.assertTrue(report.endswith("\n"))
def test_original_excepthook(self):
savestderr = sys.stderr
err = cStringIO.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError, exc:
eh(*sys.exc_info())
sys.stderr = savestderr
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def exit_by_exception():
class SignalException(BaseException):
pass
def signal_fork(signum, stack_frame):
log.info('Received signal %d, procuring hariki', signum)
raise SignalException(signum)
def excepthook(exc_type, exc_value, exc_trace):
if exc_type is SignalException:
sys.exit(1)
else:
sys.__excepthook__(exc_type, exc_value, exc_trace)
sys.excepthook = excepthook
signal.signal(signal.SIGINT, signal_fork)
signal.signal(signal.SIGTERM, signal_fork)
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print(traceback.print_tb(tb))
sys.exit(1)
else:
print(value)
sys.exit(1)
return excepthook
def exc_info_hook(exc_type, value, tb):
"""An exception hook that starts IPdb automatically on error if in interactive mode."""
if hasattr(sys, 'ps1') or not sys.stderr.isatty() or exc_type == KeyboardInterrupt:
# we are in interactive mode, we don't have a tty-like
# device,, or the user triggered a KeyboardInterrupt,
# so we call the default hook
sys.__excepthook__(exc_type, value, tb)
else:
import traceback
import ipdb
# we are NOT in interactive mode, print the exception
traceback.print_exception(exc_type, value, tb)
# then start the debugger in post-mortem mode.
# pdb.pm() # deprecated
ipdb.post_mortem(tb) # more modern
def test_original_excepthook(self):
savestderr = sys.stderr
err = cStringIO.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError, exc:
eh(*sys.exc_info())
sys.stderr = savestderr
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_original_excepthook(self):
savestderr = sys.stderr
err = cStringIO.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError, exc:
eh(*sys.exc_info())
sys.stderr = savestderr
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print traceback.print_tb(tb)
sys.exit(1)
else:
print value
sys.exit(1)
return excepthook
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print traceback.print_tb(tb)
sys.exit(1)
else:
print value
sys.exit(1)
return excepthook
def _hook(type_, value, tback):
"""Exception hook callback."""
if hasattr(sys, 'ps1') or not sys.stderr.isatty():
# we are in interactive mode or we don't have a tty-like
# device, so we call the default hook
sys.__excepthook__(type_, value, tback)
else:
import traceback
import pdb
# we are NOT in interactive mode, print the exception...
traceback.print_exception(type_, value, tback)
# Dirty hack because Py27 doesn't chain exceptions
if value.args:
tb2 = value.args[-1]
if isinstance(tb2, type(tback)):
ex = value.args[-2]
print >>sys.stderr, '{}Caused by{} '.format(
ansi('1;35m'), ansi('0m')),
traceback.print_exception(type_(ex), ex, tb2)
print
# ...then start the debugger in post-mortem mode.
# pdb.pm() # deprecated
pdb.post_mortem(tback) # more "modern"
def _log_all_uncaught_exceptions(exc_type, exc_value, exc_traceback):
"""Log all uncaught exceptions in non-interactive mode.
All python exceptions are handled by function, stored in
``sys.excepthook.`` By rewriting the default implementation, we
can modify handling of all uncaught exceptions.
Warning: modified behaviour (logging of all uncaught exceptions)
applies only when runing in non-interactive mode.
"""
# ignore KeyboardInterrupt
if not issubclass(exc_type, KeyboardInterrupt):
ROOT_LOGGER.error("", exc_info=(exc_type, exc_value, exc_traceback))
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
# Rewrite the default implementation os sys.excepthook to log all
# uncaught exceptions:
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print(traceback.print_tb(tb))
sys.exit(1)
else:
print(value)
sys.exit(1)
return excepthook
def except_hook(typ, val, tb):
"""
traceback,?:?
"""
pywinerr_list = []
sys.__excepthook__(typ, val, tb)
ex = "\n"
for e in traceback.format_exception(typ, val, tb):
ex += e
pywinerr_pos = ex.find('com_error')
if pywinerr_pos > -1:
error_str = ex[pywinerr_pos+len('com_error')+1:].strip()
xt.str2List(error_str[1:-1], pywinerr_list)
return False
#xt.inputList(pywinerr_list)
def ir_excepthook(exc_type, exc_value, exc_traceback):
"""
exception hook that sends IRException to log and other exceptions to
stderr (default excepthook)
"""
# sends full exception with trace to log
if not isinstance(exc_value, exceptions.IRException):
return sys.__excepthook__(exc_type, exc_value, exc_traceback)
if LOG.getEffectiveLevel() <= logging.DEBUG:
formated_exception = "".join(
traceback.format_exception(exc_type, exc_value, exc_traceback))
LOG.error(formated_exception + exc_value.message)
else:
LOG.error(exc_value.message)
def boto_except_hook(debugger_flag, debug_flag):
def excepthook(typ, value, tb):
if typ is bdb.BdbQuit:
sys.exit(1)
sys.excepthook = sys.__excepthook__
if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
if debugger.__name__ == 'epdb':
debugger.post_mortem(tb, typ, value)
else:
debugger.post_mortem(tb)
elif debug_flag:
print traceback.print_tb(tb)
sys.exit(1)
else:
print value
sys.exit(1)
return excepthook
def the_exception_hook(exctype, value, traceback):
'''Finds the error occurs when Osdag crashes
Args:
exctype: type of error
value: information of the error
traceback: trace the object
Returns:
system exit(1)
'''
# Print the error and traceback
print "Error occurred: ", (exctype, value, traceback)
# Call the normal Exception hook after
sys.__excepthook__(exctype, value, traceback)
sys.exit(1)
# Set the exception hook to our wrapping function
def exceptionhandler(exctype, value, traceback):
if exctype == IndexError:
parser.print_usage()
else:
sys.__excepthook__(exctype, value, traceback)
# Set the system exception handler to the above definition.
def init_logger():
logging.basicConfig(filename="pjf_{0}.log".format(time.strftime("%d_%m_%Y")), level=PYJFUZZ_LOGLEVEL)
logger = logging.getLogger(__name__)
sys.tracebacklimit = 10
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__(exc_type, exc_value, None)
return
sys.excepthook = handle_exception
return logger
def log_exception(exc_type, exc_value, exc_traceback):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
errors_logger.error("Uncaught exception\n", exc_info = (exc_type, exc_value, exc_traceback))
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))
def handleError(*args):
global last_error
if not args: # Manual called
args = sys.exc_info()
silent = True
else:
silent = False
if args[0].__name__ != "Notify":
last_error = args
if not silent and args[0].__name__ != "Notify":
logging.exception("Unhandled exception")
sys.__excepthook__(*args)
# Ignore notify errors
def handleErrorNotify(*args):
if args[0].__name__ != "Notify":
logging.exception("Unhandled exception")
sys.__excepthook__(*args)
