def excepthook(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
msg_list = traceback.format_exception_only(exc_type, exc_value)
exc_info = (exc_type, exc_value, exc_traceback)
exc_logger.exception(msg_list[-1], exc_info=exc_info)
def debugger_hook(exc, value, tb):
if (not hasattr(sys.stderr, "isatty") or
not sys.stderr.isatty() or exc in (SyntaxError, IndentationError, KeyboardInterrupt)):
sys.__excepthook__(exc, value, tb)
else:
from pycopia.fepy import debugger
debugger.post_mortem(tb, exc, value)
def handle_exception(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
logger.critical("Uncaught exception",
exc_info=(exc_type, exc_value, exc_traceback))
def info(type, value, tb):
if hasattr(sys, 'ps1') or not sys.stderr.isatty():
sys.__excepthook__(type, value, tb)
else:
import ipdb
traceback.print_exception(type, value, tb)
ipdb.post_mortem(tb)
def exceptHook(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
mainLogger = logging.getLogger("Main") # Main logger
mainLogger.critical('Uncaught exception!')
mainLogger.critical("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
def cli_exception(typ, value, traceback):
"""Handle CTRL-C by printing newline instead of ugly stack trace"""
if not issubclass(typ, KeyboardInterrupt):
sys.__excepthook__(typ, value, traceback)
else:
sys.stdout.write("\n")
sys.stdout.flush()
def uncaught_excepthook(*args):
sys.__excepthook__(*args)
if __debug__:
from pprint import pprint
from types import BuiltinFunctionType, ClassType, ModuleType, TypeType
tb = sys.last_traceback
while tb.tb_next: tb = tb.tb_next
print('\nDumping locals() ...')
pprint({k:v for k,v in tb.tb_frame.f_locals.items()
if not k.startswith('_') and
not isinstance(v, (BuiltinFunctionType,
ClassType, ModuleType, TypeType))})
if sys.stdin.isatty() and (sys.stdout.isatty() or sys.stderr.isatty()):
try:
import ipdb as pdb # try to import the IPython debugger
except ImportError:
import pdb as pdb
print '\nStarting interactive debug prompt ...'
pdb.pm()
else:
import traceback
from dialogs import ErrorDialog
ErrorDialog(_('Unexpected error'),
_('<b>The installer has failed with the following unexpected error. Please submit a bug report!</b>'),
'<tt>' + '\n'.join(traceback.format_exception(*args)) + '</tt>')
sys.exit(1)
def excepthook(exc_type, exc_value, exc_tb):
if issubclass(exc_type, subprocess.CalledProcessError):
sys.exit(exc_value.returncode)
elif issubclass(exc_type, KeyboardInterrupt):
sys.exit(128 + signal.SIGINT)
else:
sys.__excepthook__(exc_type, exc_value, exc_tb)
def debug_exceptions(type, value, tb):
base_name = "dump"
# find a browser object in the stack
frames = inspect.getinnerframes(tb)
frames.reverse() # reversed because we want the innermost first
browser = None
for frame, _, _, _, _, _ in frames:
for v in inspect.getargvalues(frame).locals.values():
if isinstance(v, Browser):
browser = v
break
localest = frames[0][0]
# stick a trace in a file
with open(base_name + '.trace', 'w') as tracefile:
tracefile.write("Locals:\n")
pprint(localest.f_locals, tracefile)
tracefile.write("\n")
if browser is not None:
tracefile.write("URL: %s\n" % browser.url)
tracefile.write("\n")
traceback.print_tb(tb, file=tracefile)
if browser is not None:
browser.save(base_name + '.html')
# then call the default handler
sys.__excepthook__(type, value, tb)
def excepthook(type, value, traceback):
message, program = format_message(type, value, traceback)
write_to_log(message)
mail_message(message, program)
# Run original exception hook
sys.__excepthook__(type, value, traceback)
def write_to_file(exc_type, exc, tb):
sys.__excepthook__(exc_type, exc, tb)
fn = "yt_traceback%s" % file_suffix
with open(fn, "w") as fhandle:
traceback.print_exception(exc_type, exc, tb, file=fhandle)
print("Wrote traceback to %s" % fn)
MPI.COMM_WORLD.Abort(1)
def uncaught_excepthook(*args):
sys.__excepthook__(*args)
if __debug__:
from pprint import pprint
from types import BuiltinFunctionType, ClassType, ModuleType, TypeType
tb = sys.last_traceback
while tb.tb_next: tb = tb.tb_next
print(('\nDumping locals() ...'))
pprint({k:v for k,v in tb.tb_frame.f_locals.items()
if not k.startswith('_') and
not isinstance(v, (BuiltinFunctionType,
ClassType, ModuleType, TypeType))})
if sys.stdin.isatty() and (sys.stdout.isatty() or sys.stderr.isatty()):
can_debug = False
try:
import ipdb as pdb # try to import the IPython debugger
can_debug = True
except ImportError:
try:
import pdb as pdb
can_debug = True
except ImportError:
pass
if can_debug:
print(('\nStarting interactive debug prompt ...'))
pdb.pm()
else:
import traceback
details = '\n'.join(traceback.format_exception(*args)).replace('<', '').replace('>', '')
title = 'Unexpected error'
msg = 'The installer has failed with the following unexpected error. Please submit a bug report!'
ErrorDialog(title, "<b>%s</b>" % msg, "<tt>%s</tt>" % details, None, True, 'live-installer-3')
sys.exit(1)
def exch(e, v, tb):
if e == NameError:
token = v.args[0].split("'")[1]
globals()[token] = 0
print('worked:', token);
goto.jump_to(tb.tb_next.tb_lineno + 1, tb.tb_next.tb_frame)
sys.__excepthook__(e, v, tb)
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 _global_except_hook(exctype, value, traceback):
"""Catches an unhandled exception and call MPI_Abort()."""
try:
if _orig_except_hook:
_orig_except_hook(exctype, value, traceback)
else:
sys.__excepthook__(exctype, value, traceback)
finally:
import mpi4py.MPI
rank = mpi4py.MPI.COMM_WORLD.Get_rank()
sys.stderr.write('\n')
sys.stderr.write('******************************************\n')
sys.stderr.write('ChainerMN: \n')
sys.stderr.write(' Uncaught exception on rank {}. \n'.format(rank))
sys.stderr.write(' Calling MPI_Abort() to shut down MPI...\n')
sys.stderr.write('******************************************\n')
sys.stderr.write('\n\n')
sys.stderr.flush()
try:
import mpi4py.MPI
mpi4py.MPI.COMM_WORLD.Abort(1)
except Exception as e:
# Something is completely broken...
# There's nothing we can do any more
sys.stderr.write(
'Sorry, failed to stop MPI and the process may hang.\n')
sys.stderr.flush()
raise e
def exception_handler(self, etype, evalue, tb):
"""
Catches crashes/ un-caught exceptions. Creates and attempts to upload the crash reports. Calls the default
exception handler (sys.__except_hook__) upon completion.
:param etype: Exception type
:param evalue: Exception value
:param tb: Traceback
:return:
"""
if CrashReporter.active:
if etype:
self.etype = etype
self.evalue = evalue
self.tb = tb
self.tb_info = analyze_traceback(tb)
# Save the offline report. If the upload of the report is successful, then delete the report.
report_path = self._save_report()
great_success = False
if self._smtp is not None:
# Send the report via email
with open(report_path, 'r') as _cr:
body = _cr.read()
great_success |= self._sendmail(self.subject(), body, self.attachments(), html=self.html)
if self._ftp is not None:
# Send the report via FTP
great_success |= self._ftp_submit(report_path)
if great_success: # Very nice..
os.remove(report_path)
else:
self.logger.info('CrashReporter: No crashes detected.')
# Call the default exception hook
sys.__excepthook__(etype, evalue, tb)
def myexcepthook(exctype, value, traceback):
if exctype == KeyboardInterrupt:
socket.close()
exi()
print "Handler code goes here"
else:
sys.__excepthook__(exctype, value, traceback)
def _custom_hook(tipe, value, traceback): # pragma: no cover
"""Custom exception hook, to print nested exceptions information."""
if hasattr(value, "child_traceback"):
sys.stderr.write("Nested exception, original traceback " +
"(most recent call last):\n")
sys.stderr.write(value.child_traceback + ("-" * 70) + "\n")
sys.__excepthook__(tipe, value, traceback)
def excepthook(*exc_args):
"""
Log exception and exit cleanly.
"""
logging.error('Unrecoverable error', exc_info=(exc_args))
sys.__excepthook__(*exc_args)
sys.exit(1)
def log_exception(exc_type, exc_value, exc_traceback):
# http://stackoverflow.com/a/16993115/2954547
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))
raise exc_type(exc_value).with_traceback(exc_traceback)
def exception_handler(type, value, traceback):
settings_diff = diff_config(
load_config(DEFAULT_CONFIG, defaults=False),
config,
exclude=set([
('lancet', 'sentry_dsn'),
])
)
sys.__excepthook__(type, value, traceback)
if type in IGNORED_EXCEPTIONS:
return
click.echo()
hr(fg='yellow')
click.secho('\nAs requested, I am sending details about this '
'error to Sentry, please report the following ID '
'when seeking support:')
error_id = sentry_client.captureException(
(type, value, traceback),
extra={
'settings': as_dict(settings_diff),
'working_dir': os.getcwd(),
},
)[0]
click.secho('\n {}\n'.format(error_id), fg='yellow')
def handle_unhandled_exceptions(exception_type, exception_value, exception_traceback):
if not issubclass(exception_type, KeyboardInterrupt):
if issubclass(exception_type, xapi.XenAPIException):
info("Returned exception to XAPI", exc_info=(exception_type, exception_value, exception_traceback))
else:
error("Unhandled exception", exc_info=(exception_type, exception_value, exception_traceback))
sys.__excepthook__(exception_type, exception_value, exception_traceback)
def fileexcepthook(exception_type, exception_value, traceback_object):
# also call the standard exception handler to have prints on the console
sys.__excepthook__(exception_type, exception_value, traceback_object)
separator = '-' * 80
log_dir = QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.AppDataLocation)[0]
logFile = os.path.join(log_dir, "friture.log")
versionInfo="Friture " + friture.__versionXXXX__
timeString = time.strftime("%Y-%m-%d, %H:%M:%S")
tbinfofile = io.StringIO()
traceback.print_tb(traceback_object, None, tbinfofile)
tbinfofile.seek(0)
tbinfo = tbinfofile.read()
errmsg = '%s: \n%s' % (str(exception_type), str(exception_value))
sections = [separator, timeString, separator, errmsg, separator, tbinfo, separator, versionInfo]
msg = '\n'.join(sections)
try:
os.makedirs(log_dir, exist_ok=True)
with open(logFile, "w") as f:
f.write(msg)
except IOError as e:
print(e)
pass
notice = \
"""An unhandled exception occurred. Please report the problem\n"""\
"""on GitHub or via email to <%s>.\n"""\
"""A log has been written to "%s".\n\nError information:\n""" % \
("*****@*****.**", logFile)
return str(notice)+str(msg)
def run(self):
try:
os.chdir(os.path.join("/var/openpanel/conf/staging", self.modname))
self.req = self.getrequest()
if self.req.command == "getconfig":
self.sendresult(0, "OK", extra=self.getconfig())
return
if self.req.command == "updateok":
if self.updateok(self.fulltree["OpenCORE:Session"]["currentversion"]):
self.sendresult(0, "OK")
else:
self.sendresult(error.ERR_MODULE_UPDATE, "Cannot update")
workerclass = self.getworkerclass(self.req.classid)
wrapper = modulecallwrapper(workerclass, self.req)
worker = getattr(wrapper, self.req.command)
result = worker()
self.sendresult(0, "OK", result)
except:
try:
self.sendresult(error.ERR_MODULE_FAILURE, ''.join(traceback.format_exception(*sys.exc_info())))
except:
sys.__excepthook__(*sys.exc_info())
def excepthook(type, value, trace):
try:
# auto.press('alt')
pass
except:
pass
sys.__excepthook__(type, value, trace)
def run(func, *args, **kwargs):
"""pdb hook: invokes pdb on exceptions in python.
The function func is called, with arguments args and
kwargs=kwargs. If this func raises an exception, pdb is invoked
on that frame. Upon exit from pdb, return to python normally."""
# save history
old_hist = _get_history()
old_hist_start = readline.get_current_history_length()+1
try:
return func(*args, **kwargs)
except Exception as e:
_add_history(_run_history)
t, value, tb = sys.exc_info()
sys.__excepthook__(t, value, tb)
frame = sys.exc_info()[2]
#tb = e.tb_frame
pdb.post_mortem(tb)
del frame # the docs warn to avoid circular references.
del t, value, tb
_run_history[:] = _get_history(first=old_hist_start)
readline.clear_history()
_restore_history(old_hist)
print old_hist
def unhandled_exception_handler(exc_type, exc_value, exc_traceback):
if current_thread().name != 'MainThread':
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
exception_info = {}
frame = wx.GetApp().GetTopWindow()
#exception_info['version'] = wx.GetApp.Version
exception_info['traceback'] = ''.join(traceback.format_exception(
exc_type, exc_value, exc_traceback))
exception_info['config'] = pprint.pformat(config)
exception_info['flamepath'] = pprint.pformat(
getattr(frame, 'flamepath', '<not set>'))
exception_info['platform'] = sys.platform
exception_info['UserParametersDir'] = wx.GetApp().UserParametersDir
exception_info['RendersDir'] = wx.GetApp().RendersDir
exception_info['UserScriptsDir'] = wx.GetApp().UserScriptsDir
exception_info['ConfigDir'] = wx.GetApp().ConfigDir
exception_info['Frozen'] = wx.GetApp().Frozen
exception_info['AppBaseDir'] = wx.GetApp().AppBaseDir
exception_info['IconsDir'] = wx.GetApp().IconsDir
msg = """Error:
%(traceback)s
Platform: %(platform)s
Config:
%(config)s
Flame Path:
%(flamepath)s
UserParametersDir: %(UserParametersDir)s
RendersDir: %(RendersDir)s
UserScriptsDir: %(UserScriptsDir)s
ConfigDir: %(ConfigDir)s
Frozen: %(Frozen)s
AppBaseDir: %(AppBaseDir)s
IconsDir: %(IconsDir)s
""" % exception_info
print msg
dlg = ExceptionDialog(frame, exc_type, exc_value, exception_info, msg)
rv = dlg.ShowModal()
dlg.Destroy()
# Pass it on to python to crash or not
sys.__excepthook__(exc_type, exc_value, exc_traceback)
if rv == wx.ID_EXIT:
sys.exit(1)
def exception_handler(type, value, traceback):
settings_diff = diff_config(
load_config(DEFAULT_CONFIG, defaults=False),
config,
exclude=set([("lancet", "sentry_dsn")]),
)
sys.__excepthook__(type, value, traceback)
if type in IGNORED_EXCEPTIONS:
return
click.echo()
hr(fg="yellow")
click.secho(
"\nAs requested, I am sending details about this "
"error to Sentry, please report the following ID "
"when seeking support:"
)
exc_info = (type, value, traceback)
event, hint = event_from_exception(
exc_info, client_options=sentry_client.options
)
event.setdefault("extra", {}).update(
{
"settings": as_dict(settings_diff),
"working_dir": os.getcwd(),
}
)
error_id = sentry_client.capture_event(event, hint=hint)
click.secho("\n {}\n".format(error_id), fg="yellow")
def uncaught_excepthook(*args):
sys.__excepthook__(*args)
if __debug__:
from pprint import pprint
from types import BuiltinFunctionType, ClassType, ModuleType, TypeType
tb = sys.last_traceback
while tb.tb_next: tb = tb.tb_next
print('\nDumping locals() ...')
pprint({k:v for k,v in tb.tb_frame.f_locals.items()
if not k.startswith('_') and
not isinstance(v, (BuiltinFunctionType,
ClassType, ModuleType, TypeType))})
if sys.stdin.isatty() and (sys.stdout.isatty() or sys.stderr.isatty()):
try:
import ipdb as pdb # try to import the IPython debugger
except ImportError:
import pdb as pdb
print('\nStarting interactive debug prompt ...')
pdb.pm()
else:
import traceback
title = _('Unexpected error')
msg = _('Debian Plymouth Manager has failed with the following unexpected error.\nPlease submit a bug report!')
msg = "<b>{}</b>\n\n<tt>{}</tt>".format(msg, '\n'.join(traceback.format_exception(*args)))
showMsg(title, msg)
sys.exit(1)
def morse_excepthook(*args, **kwargs):
logger.error("[ERROR][MORSE] Uncaught exception, quit Blender.", exc_info = tuple(args))
# call default python exception hook
# on Ubuntu/Python3.4 sys.excepthook is overriden by `apport_excepthook`
sys.__excepthook__(*args, **kwargs)
import os
os._exit(-1)
def handle_exception(exc_type, exc_value, exc_traceback):
"""Exception handler to log any uncaught exceptions"""
logging.error("Uncaught exception",
exc_info=(exc_type, exc_value, exc_traceback))
sys.__excepthook__(exc_type, exc_value, exc_traceback)
def log_exception(exc_type, exc_value, exc_traceback):
if not issubclass(exc_type, KeyboardInterrupt):
log.critical("Uncaught exception",
exc_info=(exc_type, exc_value, exc_traceback))
sys.__excepthook__(exc_type, exc_value, exc_traceback)
def except_hook(cls, exception, traceback):
sys.__excepthook__(cls, exception, traceback)
def excepthook(type, value, traceback):
sys.__excepthook__(type, value, traceback)
logging.critical('Crash! Killing all miners.')
os.killpg(os.getpgid(0), signal.SIGKILL) # (This also kills us.)
def exception_hook(self, type, value, trace): """""" message = get_exception_info(type, value, trace) logger.critical(message) sys.__excepthook__(type, value, trace) sys.exit(-1)
def _ansible_excepthook(exc_type, exc_value, tb):
# Using an exception allows us to catch it if the calling code knows it can recover
if issubclass(exc_type, AnsibleModuleError):
module.fail_json(**exc_value.results)
else:
sys.__excepthook__(exc_type, exc_value, tb)
def testExceptionHook(type, value, tback):
self.no_exceptions = False
self.exception_info = (type, value, tback)
sys.__excepthook__(type, value, tback)
import os
import pkg_resources
import pandas as pd
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import Qt
from pandasgui.widgets import PivotDialog, ScatterDialog
from pandasgui.widgets import DataFrameExplorer
from pandasgui.widgets import FindToolbar
from pandasgui.widgets import HeaderWidget
from pandasgui.utility import fix_ipython
# This makes it so PyQt5 windows don't become unresponsive in IPython outside app._exec() loops
fix_ipython()
# Provides proper stacktrace if PyQt crashes
sys.excepthook = lambda cls, exception, traceback: sys.__excepthook__(
cls, exception, traceback)
# Holds references to all created PandasGUI windows so they don't get garbage collected
instance_list = []
class PandasGUI(QtWidgets.QMainWindow):
def __init__(self, **kwargs):
"""
Args:
**kwargs (): Dict of (key, value) pairs of
{'DataFrame name': DataFrame object}
self.df_dicts is a dictionary of all dataframes in the GUI.
{dataframe name: objects}
def excepthook(exctype, value, traceback):
logging.exception('exception')
return sys.__excepthook__(exctype, value, traceback)
self.browser2.hide()
self.lab_selected.hide()
def _chClicked(self, evt, ch):
if ch != self._old:
self._update(self._old, ch)
self._old = ch
ch._mousePressEvent(evt)
def show(self):
super().show()
if self.gui is not None:
self._decorateCurrentTab()
def hide(self):
super().hide()
self._decorateCurrentTab()
if __name__ == '__main__':
import sys
#######################
# temporary fix: app crack doesnt through exception
# https://stackoverflow.com/questions/38020020/pyqt5-app-exits-on-error-where-pyqt4-app-would-not
sys.excepthook = lambda t, v, b: sys.__excepthook__(t, v, b)
#######################
app = QtWidgets.QApplication([])
w = Help(None)
w.show()
app.exec_()
def _earlyExceptionHandler(ty, value, traceback):
util.ipmi_report(constants.IPMI_FAILED)
util.vtActivate(1)
return sys.__excepthook__(ty, value, traceback)
def excepthook(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, ErrorMessage):
_ = sys.stderr.write("{}\n".format(exc_value))
else:
sys.__excepthook__(exc_type, exc_value, exc_traceback)
def default_sys_except_hook(cls, exception, traceback):
sys.__excepthook__(cls, exception, traceback)
def on_close(self):
Exception_Window._active_window = None
sys.__excepthook__(*self.exc_args)
self.close()
def no_abort(a, b, c):
sys.__excepthook__(a, b, c)
def excepthook(exctype, value, traceback):
if issubclass(exctype, Exception):
client.captureException(exc_info=(exctype, value, traceback))
sys.__excepthook__(exctype, value, traceback)
def exceptionhandler(exctype, value, traceback):
if exctype == IndexError:
parser.print_usage()
else:
sys.__excepthook__(exctype, value, traceback)
def wdb_pm(xtype, value, traceback):
sys.__excepthook__(xtype, value, traceback)
wdb = Wdb.get()
wdb.reset()
wdb.interaction(None, traceback, post_mortem=True)
def except_hook(type, value, traceback):
sys.__excepthook__(type, value, traceback)
input('Press any key to exit...\n')
def error_excepthook(exctype, value, traceback):
print 'ERROR:'
sys.__excepthook__(exctype, value, traceback)
def except_hook(cls, exception, traceback):
"""
Отображение исключений
"""
sys.__excepthook__(cls, exception, traceback)
def excepthook(type, value, tback):
logging.error('Line %d, %s: %s', tback.tb_lineno, type, value)
sys.__excepthook__(type, value, tback)
def handle_exception(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
logger.debug("Uncaught exception",
exc_info=(exc_type, exc_value, exc_traceback))
def except_hook(cls, exception, traceback):
# PyQt5 has changed how it handles exceptions, this restores printing traceback to IDEs
# https://stackoverflow.com/questions/33736819/pyqt-no-error-msg-traceback-on-exit
sys.__excepthook__(cls, exception, traceback)
exit()
def cleanup(type, value, traceback):
sys.__excepthook__(type, value, traceback)
MPI.COMM_WORLD.Abort(1)
def myexcepthook(exctype, value, traceback):
if exctype == ProcessCanceled:
logger.info("User cancelled operation")
else:
sys.__excepthook__(exctype, value, traceback)
def excepthook(self, type, value, trace):
self._logger.error(u"An unhandled exception occured.",
exc_info=(type, value, trace))
sys.__excepthook__(type, value, trace)
def print_error(exc_type, exc_value, exc_traceback, *args):
if any(issubclass(exc_type, c) for c in ALWAYS_RAISE):
# let the system handle important exceptions
sys.__excepthook__(*args)
sys.stderr.write(traceback.format_exc())
def handler(t, value, traceback):
if self.args.verbose:
sys.__excepthook__(t, value, traceback)
else:
print value
def handle_exc(self, type, value, traceback):
self.broker.produce(
self.client.build_msgpack_event_data(type, traceback, self.tree),
"event")
sys.__excepthook__(type, value, traceback)
