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 __init__( self, app ):
self.app = app
self.__log_widget = WbLogTextWidget( self.app )
self.__line = ''
# Redirect the console IO to this panel
sys.stdin = wb_platform_specific.getNullDevice().open( 'r' )
if self.app.stdIoRedirected():
sys.stdout = self
sys.stderr = self
sys.excepthook = self.excepthook
# Redirect log to the Log panel
self.widget_log_handler = WidgetLogHandler( self.app, self.__log_widget )
self.app.log.addHandler( self.widget_log_handler )
self.__session_log = open( str(wb_platform_specific.getLogFilename()) + '.session.log', 'w', buffering=1 )
def excepthook( self, type_, value, tb ):
# emergency write
self.__session_log.write( 'excepthook called\n' )
self.__session_log.flush()
all_exception_lines = traceback.format_exception( type_, value, tb )
for line in all_exception_lines:
self.__session_log.write( line )
self.__session_log.flush()
# cannot use the GUI window now app is not sane
self.app.log.removeHandler( self.widget_log_handler )
self.app.log.error( 'excepthook called' )
for line in all_exception_lines:
self.app.log.error( line.replace( '\n', '' ) )
self.app.runInForeground( self.app.log.addHandler, (self.widget_log_handler,) )
self.app.runInForeground( self.app.log.error, ('Check log for traceback details',) )
def pre_arg_parse_except_hook(memory_handler, *args, **kwargs):
"""A simple wrapper around post_arg_parse_except_hook.
The additional functionality provided by this wrapper is the memory
handler will be flushed before Certbot exits. This allows us to
write logging messages to a temporary file if we crashed before
logging was fully configured.
Since sys.excepthook isn't called on SystemExit exceptions, the
memory handler will not be flushed in this case which prevents us
from creating temporary log files when argparse exits because a
command line argument was invalid or -h, --help, or --version was
provided on the command line.
:param MemoryHandler memory_handler: memory handler to flush
:param tuple args: args for post_arg_parse_except_hook
:param dict kwargs: kwargs for post_arg_parse_except_hook
"""
try:
post_arg_parse_except_hook(*args, **kwargs)
finally:
# flush() is called here so messages logged during
# post_arg_parse_except_hook are also flushed.
memory_handler.flush(force=True)
def __init__(self, user_data_control):
super().__init__()
sys.excepthook = self._displayError
self._udc = user_data_control
self.check = QPixmap("res/check.png")
self.cancel = QPixmap("res/cancel.png")
self.setGeometry(500, 500, 500, 465)
self.init_ui()
self.init_window()
self.init_user_data()
self.setWindowTitle(self.APP_TITLE)
self.setWindowIcon(QIcon('res/rabbit.png'))
center(self)
self.show()
# PyQt Error Handling
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 process_standard_options(self, options, args, d):
if hasattr(options, 'help_filters') and options.help_filters:
print('Available filters:')
for filter in self.Filters:
print('%s\t%s' % (filter.name, filter.doc))
sys.exit(0)
if options.debug:
self.args['debug'] = 2
if options.url:
self.args['url'] = options.url
if options.region:
self.args['region'] = options.region
if options.access_key_id:
self.args['aws_access_key_id'] = options.access_key_id
if options.secret_key:
self.args['aws_secret_access_key'] = options.secret_key
if options.version:
# TODO - Where should the version # come from?
print('version x.xx')
exit(0)
sys.excepthook = boto_except_hook(options.debugger,
options.debug)
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 init_traceback_handlers(self, custom_exceptions):
# Syntax error handler.
self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor', parent=self)
# The interactive one is initialized with an offset, meaning we always
# want to remove the topmost item in the traceback, which is our own
# internal code. Valid modes: ['Plain','Context','Verbose']
self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
color_scheme='NoColor',
tb_offset = 1,
check_cache=check_linecache_ipython,
debugger_cls=self.debugger_cls, parent=self)
# The instance will store a pointer to the system-wide exception hook,
# so that runtime code (such as magics) can access it. This is because
# during the read-eval loop, it may get temporarily overwritten.
self.sys_excepthook = sys.excepthook
# and add any custom exception handlers the user may have specified
self.set_custom_exc(*custom_exceptions)
# Set the exception mode
self.InteractiveTB.set_mode(mode=self.xmode)
def excepthook(self, etype, value, tb):
"""One more defense for GUI apps that call sys.excepthook.
GUI frameworks like wxPython trap exceptions and call
sys.excepthook themselves. I guess this is a feature that
enables them to keep running after exceptions that would
otherwise kill their mainloop. This is a bother for IPython
which excepts to catch all of the program exceptions with a try:
except: statement.
Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
any app directly invokes sys.excepthook, it will look to the user like
IPython crashed. In order to work around this, we can disable the
CrashHandler and replace it with this excepthook instead, which prints a
regular traceback using our InteractiveTB. In this fashion, apps which
call sys.excepthook will generate a regular-looking exception from
IPython, and the CrashHandler will only be triggered by real IPython
crashes.
This hook should be used sparingly, only in places which are not likely
to be true IPython errors.
"""
self.showtraceback((etype, value, tb), tb_offset=0)
def __init__(self, **kw):
if kw.get('user_global_ns', None) is not None:
raise DeprecationWarning(
"Key word argument `user_global_ns` has been replaced by `user_module` since IPython 4.0.")
clid = kw.pop('_init_location_id', None)
if not clid:
frame = sys._getframe(1)
clid = '%s:%s' % (frame.f_code.co_filename, frame.f_lineno)
self._init_location_id = clid
super(InteractiveShellEmbed,self).__init__(**kw)
# don't use the ipython crash handler so that user exceptions aren't
# trapped
sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
mode=self.xmode,
call_pdb=self.pdb)
def enable_pyqt_exception_hook():
"""Enable the PyQt exception handling hook for PyQt versions larger than 5.5.
If this is not enabled, exceptions will be handled silently and will not be printed to the user. This
makes it harder to solve the issue.
"""
if QtCore.QT_VERSION >= 0x50501:
old_stdout = sys.stdout
old_stderr = sys.stderr
def excepthook(type_, value, traceback_):
sys.stdout = old_stdout
sys.stderr = old_stderr
traceback.print_exception(type_, value, traceback_)
QtCore.qFatal('')
sys.excepthook = excepthook
def test_perform_changes_dpkg_error_retains_excepthook(self):
"""
We install a special excepthook when preforming package
operations, to prevent Apport from generating crash reports when
dpkg returns a failure. It's only installed when doing the
actual package operation, so the original excepthook is there
after the perform_changes() method returns.
"""
old_excepthook = sys.excepthook
self._add_system_package("foo")
self.facade.reload_channels()
foo = self.facade.get_packages_by_name("foo")[0]
self.facade.mark_remove(foo)
with self.assertRaises(TransactionError):
self.facade.perform_changes()
self.assertIs(old_excepthook, sys.excepthook)
def set_cli_except_hook():
def recommend(possible_solutions):
logger.info('Possible solutions:')
for solution in possible_solutions:
logger.info(' - {0}'.format(solution))
def new_excepthook(tpe, value, trace):
if env.logging.is_high_verbose_level():
# log error including traceback
logger.error(get_exception_as_string(tpe, value, trace))
else:
# write the full error to the log file
with open(env.logging.log_file, 'a') as log_file:
traceback.print_exception(
etype=tpe,
value=value,
tb=trace,
file=log_file)
# print only the error message
print value
if hasattr(value, 'possible_solutions'):
recommend(getattr(value, 'possible_solutions'))
sys.excepthook = new_excepthook
def __call__(self, parser, namespace, values, option_string = None):
# If we recognize one of the arguments on the command line as indicating a
# different mechanism for handling tracebacks, we attach one of those handlers
# and remove the argument from sys.argv.
#
if self.dest == "paste":
sys.excepthook = paste_traceback
mylog.debug("Enabling traceback pasting")
elif self.dest == "paste-detailed":
sys.excepthook = paste_traceback_detailed
mylog.debug("Enabling detailed traceback pasting")
elif self.dest == "detailed":
import cgitb
cgitb.enable(format="text")
mylog.debug("Enabling detailed traceback reporting")
elif self.dest == "rpdb":
sys.excepthook = rpdb.rpdb_excepthook
mylog.debug("Enabling remote debugging")
def main():
"""Main function."""
sys.excepthook = error_handler
try:
signal.signal(signal.SIGINT, sigint_handler)
except ValueError:
print('Warning: couldn\'t start SIGINT (ctrl-c) handler.')
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
app = QApplication(sys.argv)
app.setStyleSheet(stylesheets[0])
window = DiscordWindow()
timer = QTimer()
timer.start(20) # let interpreter run every 550ms
timer.timeout.connect(lambda: None)
window.show()
window.raise_()
window.setWindowState(window.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
window.activateWindow() # mac...
app.aboutToQuit.connect(lambda: quit_cleanup(window))
exc = app.exec_()
return exc
def prehook(self, emu, op, starteip):
if not self.onceop.get(starteip):
self.onceop[starteip] = True
for i, o in enumerate(op.opers):
if o.isDeref():
discrete = o.isDiscrete()
operva = o.getOperAddr(op, emu)
# keep track of the max here, but save it for later too...
stackoff = emu.getStackOffset(operva)
if stackoff is not None: # py 2->3 specific
if stackoff >= 0:
self.stackmax = max(self.stackmax, stackoff)
self.operrefs.append((starteip, i, operva, o.tsize, stackoff, discrete))
if op.iflags & BRANCH_FLAGS:
oper = op.opers[0]
if oper.isDeref() or oper.isReg():
for cb in self._dynamic_branch_handlers:
try:
cb(self, emu, op, starteip)
except:
sys.excepthook(*sys.exc_info())
def except_hook(exception_type, value, tb):
if show_messagebox_on_exception:
focused_widget = QApplication.focusWidget()
if focused_widget:
if exception_type == type_defs.GDBInitializeException:
QMessageBox.information(focused_widget, "Error", "GDB isn't initialized yet")
elif exception_type == type_defs.InferiorRunningException:
error_dialog = InputDialogForm(item_list=[("Process is running" +
"\nPress " + break_hotkey + " to stop process" +
"\n\nGo to settings->General to disable this dialog",)])
error_dialog.exec_()
traceback.print_exception(exception_type, value, tb)
# From version 5.5 and onwards, PyQT calls qFatal() when an exception has been encountered
# So, we must override sys.excepthook to avoid calling of qFatal()
def _run_handlers():
"""_run_handlers()
Run registered handlers. They run in the reverse order of which they were
registered.
If a handler raises an exception, it will be printed but nothing else
happens, i.e. other handlers will be run.
"""
context.clear()
for _ident, (func, args, kwargs, ctx) in \
sorted(_handlers.items(), reverse = True):
try:
with context.local(**ctx):
func(*args, **kwargs)
except SystemExit:
pass
except:
# extract the current exception and rewind the traceback to where it
# originated
typ, val, tb = sys.exc_info()
traceback.print_exception(typ, val, tb.tb_next)
# we rely on the existing excepthook to print exceptions
def failed(self):
# check, if the reason was a ConfigureDryRunError or a
# ConfigureCacheError and if yes, reraise the exception
exc_type = self.exc_info()[0]
if issubclass(exc_type, SConfError):
raise
elif issubclass(exc_type, SCons.Errors.BuildError):
# we ignore Build Errors (occurs, when a test doesn't pass)
# Clear the exception to prevent the contained traceback
# to build a reference cycle.
self.exc_clear()
else:
self.display('Caught exception while building "%s":\n' %
self.targets[0])
sys.excepthook(*self.exc_info())
return SCons.Taskmaster.Task.failed(self)
def configure_logging(self, level=logging.INFO, debug=False):
""" Configures the basic logging for the experiment. This creates a handler for logging to the console, sets it at the appropriate level (info by default unless overridden in the config file or by the debug flag) and creates the default formatting for log messages.
"""
if debug is True:
self.log_level = logging.DEBUG
else:
self.log_level = level
sys.excepthook = _log_except_hook # send uncaught exceptions to file
logging.basicConfig(
level=self.log_level,
format='"%(asctime)s","%(levelname)s","%(message)s"'
)
# Make sure that the stream handler has the requested log level.
root_logger = logging.getLogger()
for handler in root_logger.handlers:
if isinstance(handler, logging.StreamHandler):
handler.setLevel(self.log_level)
def _set_pm_excepthook(handle_exceptions_dict=None):
'''
Should be called to register the excepthook to be used.
It's only useful for uncaught exceptions. I.e.: exceptions that go up to the excepthook.
@param handle_exceptions: dict(exception -> ExceptionBreakpoint)
The exceptions that should be handled.
'''
global _handle_exceptions
global _original_excepthook
if sys.excepthook != _excepthook:
#Only keep the original if it's not our own _excepthook (if called many times).
_original_excepthook = sys.excepthook
_handle_exceptions = handle_exceptions_dict
sys.excepthook = _excepthook
def showsyntaxerror(self, filename=None):
"""Display the syntax error that just occurred."""
#Override for avoid using sys.excepthook PY-12600
type, value, tb = sys.exc_info()
sys.last_type = type
sys.last_value = value
sys.last_traceback = tb
if filename and type is SyntaxError:
# Work hard to stuff the correct filename in the exception
try:
msg, (dummy_filename, lineno, offset, line) = value.args
except ValueError:
# Not the format we expect; leave it alone
pass
else:
# Stuff in the right filename
value = SyntaxError(msg, (filename, lineno, offset, line))
sys.last_value = value
list = traceback.format_exception_only(type, value)
sys.stderr.write(''.join(list))
def showtraceback(self):
"""Display the exception that just occurred."""
#Override for avoid using sys.excepthook PY-12600
try:
type, value, tb = sys.exc_info()
sys.last_type = type
sys.last_value = value
sys.last_traceback = tb
tblist = traceback.extract_tb(tb)
del tblist[:1]
lines = traceback.format_list(tblist)
if lines:
lines.insert(0, "Traceback (most recent call last):\n")
lines.extend(traceback.format_exception_only(type, value))
finally:
tblist = tb = None
sys.stderr.write(''.join(lines))
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 process_standard_options(self, options, args, d):
if hasattr(options, 'help_filters') and options.help_filters:
print('Available filters:')
for filter in self.Filters:
print('%s\t%s' % (filter.name, filter.doc))
sys.exit(0)
if options.debug:
self.args['debug'] = 2
if options.url:
self.args['url'] = options.url
if options.region:
self.args['region'] = options.region
if options.access_key_id:
self.args['aws_access_key_id'] = options.access_key_id
if options.secret_key:
self.args['aws_secret_access_key'] = options.secret_key
if options.version:
# TODO - Where should the version # come from?
print('version x.xx')
exit(0)
sys.excepthook = boto_except_hook(options.debugger,
options.debug)
def prototype(*outer_args,**outer_kwargs):
""" Verify that a method is called with a valid data type value.
The datatype of a parameter must be a one of the type
defined in types package.
"""
def decorator(fn):
def decorated(*args,**kwargs):
#do_something(*outer_args,**outer_kwargs)
if len(outer_args)!=len(args):
sys.excepthook = __exceptionHandler__
raise Exception("Invalid Number of "
"arguments in function call")
for [typ, var] in zip(outer_args, args):
if ( isinstance(var, typ)):
pass
else:
sys.excepthook = __exceptionHandler__
raise Exception("Invalid Type")
return fn(*args,**kwargs)
return decorated
return decorator
def ovrprototype(*outer_args,**outer_kwargs):
""" Verify that a method is called with a valid data type value.
The datatype of a parameter must be a list of type defined
in package types.
"""
def decorator(fn):
def decorated(*args,**kwargs):
#do_something(*outer_args,**outer_kwargs)
if len(outer_args)!=len(args):
sys.excepthook = __exceptionHandler__
raise Exception("Invalid Number of "
"arguments in function call")
for [typ, var] in zip(outer_args, args):
matched = False
for i_typ in typ:
if ( isinstance(var, i_typ)):
matched = True
break
if matched == False:
sys.excepthook = __exceptionHandler__
raise Exception("Invalid Type")
return fn(*args,**kwargs)
return decorated
return decorator
