def format(self, record):
"""Format exception object as a string"""
data = record._raw.copy()
data['extra'] = self.prepare_data(data.get('extra'))
if 'exc_info' in data and data['exc_info']:
if DJANGO_ENABLE:
er = ExceptionReporter(None, *data['exc_info'])
data['exc_extra_info'] = self.prepare_data(er.get_traceback_frames())
data['exc_info'] = self.formatException(data['exc_info'])
data['msg'] = logging.Formatter.format(self, record)
data['format'] = data['msg']
del data['args']
# hack for normalize unicode data for soap fault
for key in ['exc_info', 'format']:
if isinstance(data[key], basestring):
try:
data[key] = data[key].decode("unicode_escape")
except UnicodeEncodeError:
pass
return data
def handler500(request):
if hasattr(request, 'urlconf'):
urlconf = request.urlconf
set_urlconf(urlconf)
resolver = get_resolver(urlconf)
else:
resolver = get_resolver()
resolver_match = resolver.resolve(request.path_info)
callback, callback_args, callback_kwargs = resolver_match
request.resolver_match = resolver_match
obj = base.BaseHandler
wrapped_callback = obj.make_view_atomic(obj, callback)
try:
response = wrapped_callback(request, *callback_args, **callback_kwargs)
except Exception as e:
exc_type, exc_value, tb = sys.exc_info()
reporter = ExceptionReporter(request, exc_type, exc_value, tb)
frames = reporter.get_traceback_frames()
traceback_string = ""
for frame in frames:
traceback_string += "({},{})".format(str(frame['lineno']),
str(frame['filename']))
logger.critical("|URL->| {} |ERROR->| {} |TRACEBACK->| {}".format(request,\
e, traceback_string))
return HttpResponse(status=500)
def create_from_exception(self, exception=None, traceback=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exception:
exc_type, exc_value, traceback = sys.exc_info()
elif not traceback:
warnings.warn('Using just the ``exception`` argument is deprecated, send ``traceback`` in addition.', DeprecationWarning)
exc_type, exc_value, traceback = sys.exc_info()
else:
exc_type = exception.__class__
exc_value = exception
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
return f
def shorten(var):
if not isinstance(var, basestring):
var = to_unicode(var)
if len(var) > 500:
var = var[:500] + '...'
return var
reporter = ExceptionReporter(None, exc_type, exc_value, traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
data = kwargs.pop('data', {}) or {}
data['__sentry__'] = {
'exc': map(to_unicode, [exc_type.__class__.__module__, exc_value.args, frames]),
}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, 'source'):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
tb_message = '\n'.join(traceback_mod.format_exception(exc_type, exc_value, traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self._create(
class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs
)
def create_from_exception(self, exception=None, traceback=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exception:
exc_type, exc_value, traceback = sys.exc_info()
elif not traceback:
warnings.warn(
"Using just the ``exception`` argument is deprecated, send ``traceback`` in addition.",
DeprecationWarning,
)
exc_type, exc_value, traceback = sys.exc_info()
else:
exc_type = exception.__class__
exc_value = exception
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = "(Error decoding value)"
except Exception: # in some cases we get a different exception
f = smart_unicode(type(f))
return f
def shorten(var):
if not isinstance(var, basestring):
var = to_unicode(var)
if len(var) > 500:
var = var[:500] + "..."
return var
reporter = ExceptionReporter(None, exc_type, exc_value, traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
data = kwargs.pop("data", {}) or {}
data["__sentry__"] = {"exc": map(to_unicode, [exc_type.__class__.__module__, exc_value.args, frames])}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, "source"):
origin, (start, end) = exc_value.source
data["__sentry__"].update({"template": (origin.reload(), start, end, origin.name)})
tb_message = "\n".join(traceback_mod.format_exception(exc_type, exc_value, traceback))
kwargs.setdefault("message", to_unicode(exc_value))
return self.process(class_name=exc_type.__name__, traceback=tb_message, data=data, **kwargs)
def create_from_exception(self, exception=None, traceback=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exception:
exc_type, exc_value, traceback = sys.exc_info()
elif not traceback:
warnings.warn(
'Using just the ``exception`` argument is deprecated, send ``traceback`` in addition.',
DeprecationWarning)
exc_type, exc_value, traceback = sys.exc_info()
else:
exc_type = exception.__class__
exc_value = exception
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
return f
reporter = ExceptionReporter(None, exc_type, exc_value, traceback)
frames = reporter.get_traceback_frames()
data = kwargs.pop('data', {}) or {}
data['exc'] = base64.b64encode(
pickle.dumps(
map(to_unicode,
[exc_type.__class__.__module__, exc_value.args, frames
])).encode('zlib'))
tb_message = '\n'.join(
traceback_mod.format_exception(exc_type, exc_value, traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self._create(class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs)
def create_from_exception(self, exception=None, traceback=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exception:
exc_type, exc_value, traceback = sys.exc_info()
elif not traceback:
warnings.warn('Using just the ``exception`` argument is deprecated, send ``traceback`` in addition.', DeprecationWarning)
exc_type, exc_value, traceback = sys.exc_info()
else:
exc_type = exception.__class__
exc_value = exception
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
return f
reporter = ExceptionReporter(None, exc_type, exc_value, traceback)
frames = reporter.get_traceback_frames()
data = kwargs.pop('data', {}) or {}
try:
data['exc'] = base64.b64encode(pickle.dumps(map(to_unicode, [exc_type.__class__.__module__, exc_value.args, frames])).encode('zlib'))
except:
data['exc'] = base64.b64encode(pickle.dumps(map(to_unicode, [exc_type.__class__.__module__, exc_value.args, []])).encode('zlib'))
tb_message = '\n'.join(traceback_mod.format_exception(exc_type, exc_value, traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self._create(
class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs
)
def test_reporting_frames_without_source(self):
try:
source = "def funcName():\n raise Error('Whoops')\nfuncName()"
namespace = {}
code = compile(source, 'generated', 'exec')
exec(code, namespace)
except Exception:
exc_type, exc_value, tb = sys.exc_info()
request = self.rf.get('/test_view/')
reporter = ExceptionReporter(request, exc_type, exc_value, tb)
frames = reporter.get_traceback_frames()
last_frame = frames[-1]
self.assertEqual(last_frame['context_line'], '<source code not available>')
self.assertEqual(last_frame['filename'], 'generated')
self.assertEqual(last_frame['function'], 'funcName')
self.assertEqual(last_frame['lineno'], 2)
html = reporter.get_traceback_html()
self.assertIn('generated in funcName', html)
text = reporter.get_traceback_text()
self.assertIn('"generated" in funcName', text)
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
except Exception: # in some cases we get a different exception
f = smart_unicode(type(f))
return f
def shorten(var):
if not isinstance(var, basestring):
var = to_unicode(var)
if len(var) > 200:
var = var[:200] + '...'
return var
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get('view'):
# This should be cached
modules = get_installed_apps()
if conf.INCLUDE_PATHS:
modules = set(list(modules) + conf.INCLUDE_PATHS)
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
view = None
for frame in iter_tb_frames(exc_traceback):
view = '.'.join([frame.f_globals['__name__'], frame.f_code.co_name])
if contains(modules, view):
if not (contains(conf.EXCLUDE_PATHS, view) and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
if view:
kwargs['view'] = view
data = kwargs.pop('data', {}) or {}
data['__sentry__'] = {
'exc': map(to_unicode, [exc_type.__class__.__module__, exc_value.args, frames]),
}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, 'source'):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
kwargs['view'] = origin.loadname
tb_message = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self.process(
class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs
)
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
def shorten(var):
var = transform(var)
if isinstance(var, basestring) and len(var) > 200:
var = var[:200] + '...'
return var
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get('view'):
# This should be cached
modules = get_installed_apps()
if conf.INCLUDE_PATHS:
modules = set(list(modules) + conf.INCLUDE_PATHS)
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
view = None
for frame in iter_tb_frames(exc_traceback):
try:
view = '.'.join(
[frame.f_globals['__name__'], frame.f_code.co_name])
except:
continue
if contains(modules, view):
if not (contains(conf.EXCLUDE_PATHS, view) and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
if view:
kwargs['view'] = view
data = kwargs.pop('data', {}) or {}
if hasattr(exc_type, '__class__'):
exc_module = exc_type.__class__.__module__
else:
exc_module = None
data['__sentry__'] = {
'exc': map(transform, [exc_module, exc_value.args, frames]),
}
if (isinstance(exc_value, TemplateSyntaxError) and \
isinstance(getattr(exc_value, 'source', None), (tuple, list)) and isinstance(exc_value.source[0], LoaderOrigin)):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
kwargs['view'] = origin.loadname
tb_message = '\n'.join(
traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault('message', transform(force_unicode(exc_value)))
return self.process(class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs)
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get('view'):
# This should be cached
modules = get_installed_apps()
if conf.INCLUDE_PATHS:
modules = set(list(modules) + conf.INCLUDE_PATHS)
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
view = None
for frame in iter_tb_frames(exc_traceback):
try:
view = '.'.join([frame.f_globals['__name__'], frame.f_code.co_name])
except:
continue
if contains(modules, view):
if not (contains(conf.EXCLUDE_PATHS, view) and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
if view:
kwargs['view'] = view
data = kwargs.pop('data', {}) or {}
if hasattr(exc_type, '__class__'):
exc_module = exc_type.__class__.__module__
else:
exc_module = None
data['__sentry__'] = {
'exc': map(transform, [exc_module, exc_value.args, frames]),
}
if (isinstance(exc_value, TemplateSyntaxError) and \
isinstance(getattr(exc_value, 'source', None), (tuple, list)) and isinstance(exc_value.source[0], LoaderOrigin)):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
kwargs['view'] = origin.loadname
tb_message = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault('message', transform(force_unicode(exc_value)))
return self.process(
class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs
)
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
def shorten(var):
var = transform(var)
if isinstance(var, basestring) and len(var) > 200:
var = var[:200] + "..."
return var
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get("view"):
# This should be cached
modules = get_installed_apps()
if conf.INCLUDE_PATHS:
modules = set(list(modules) + conf.INCLUDE_PATHS)
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
view = None
for frame in iter_tb_frames(exc_traceback):
try:
view = ".".join([frame.f_globals["__name__"], frame.f_code.co_name])
except:
continue
if contains(modules, view):
if not (contains(conf.EXCLUDE_PATHS, view) and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
if view:
kwargs["view"] = view
data = kwargs.pop("data", {}) or {}
if hasattr(exc_type, "__class__"):
exc_module = exc_type.__class__.__module__
else:
exc_module = None
data["__sentry__"] = {"exc": map(transform, [exc_module, exc_value.args, frames])}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, "source"):
origin, (start, end) = exc_value.source
data["__sentry__"].update({"template": (origin.reload(), start, end, origin.name)})
kwargs["view"] = origin.loadname
tb_message = "\n".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault("message", transform(force_unicode(exc_value)))
return self.process(class_name=exc_type.__name__, traceback=tb_message, data=data, **kwargs)
def handle(self, exc_info=None):
# TODO: remove Django specifics
from django.template import TemplateSyntaxError
from django.views.debug import ExceptionReporter
if exc_info is None:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
result = {
'tags': [('level', 'error')],
}
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
exc_frames = varmap(shorten, reporter.get_traceback_frames())
# This should be cached
# modules = get_installed_apps()
modules = []
if app.config['INCLUDE_PATHS']:
modules = set(list(modules) + app.config['INCLUDE_PATHS'])
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
view = None
for frame in iter_tb_frames(exc_traceback):
try:
view = '.'.join([frame.f_globals['__name__'], frame.f_code.co_name])
except:
continue
if contains(modules, view):
if not (contains(app.config['EXCLUDE_PATHS'], view) and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
if view:
result['tags'].append(('view', view))
if hasattr(exc_type, '__class__'):
exc_module = exc_type.__class__.__module__
if exc_module == '__builtin__':
exc_type = exc_type.__name__
else:
exc_type = '%s.%s' % (exc_module, exc_type.__name__)
else:
exc_module = None
exc_type = exc_type.__name__
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, 'source'):
origin, (start, end) = exc_value.source
result['exc_template'] = (origin.reload(), start, end, origin.name)
result['tags'].append(('template', origin.loadname))
result['exc_value'] = transform(exc_value)
result['exc_type'] = exc_type
result['exc_frames'] = self.get_traceback_frames(exc_traceback)
return result
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
except Exception: # in some cases we get a different exception
f = smart_unicode(type(f))
return f
def shorten(var):
if not isinstance(var, basestring):
var = to_unicode(var)
if len(var) > 200:
var = var[:200] + '...'
return var
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get('view'):
# This should be cached
modules = get_installed_apps()
if settings.INCLUDE_PATHS:
modules = set(list(modules) + settings.INCLUDE_PATHS)
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
def contains(iterator, value):
for k in iterator:
if value.startswith(k):
return True
return False
# We iterate through each frame looking for an app in INSTALLED_APPS
# When one is found, we mark it as last "best guess" (best_guess) and then
# check it against SENTRY_EXCLUDE_PATHS. If it isnt listed, then we
# use this option. If nothing is found, we use the "best guess".
best_guess = None
for frame in iter_tb_frames(exc_traceback):
view = '.'.join(
[frame.f_globals['__name__'], frame.f_code.co_name])
if contains(modules, view):
if not (contains(settings.EXCLUDE_PATHS, view)
and best_guess):
best_guess = view
elif best_guess:
break
if best_guess:
view = best_guess
kwargs['view'] = view
data = kwargs.pop('data', {}) or {}
data['__sentry__'] = {
'exc':
map(to_unicode,
[exc_type.__class__.__module__, exc_value.args, frames]),
}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(
exc_value, 'source'):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
kwargs['view'] = origin.loadname
tb_message = '\n'.join(
traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self.process(class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs)
def emit(self, record):
if record.exc_info:
exc_info = record.exc_info
reporter = ExceptionReporter(record.request, *exc_info)
# Create the SnowyEvening stack trace
frames = [
{
"file" : i['filename'],
"line" : i['lineno'],
"function" : i['function']
}
for i in reporter.get_traceback_frames()[::-1]
]
error_type = exc_info[0].__name__
error_message = exc_info[0].__name__ + ": " + unicode(exc_info[1])
file_path = frames[0]['file']
line = str(frames[0]['line'])
else:
exc_info = (None, record.getMessage(), None)
reporter = ExceptionReporter(record.request, *exc_info)
frames = []
error_type = "Logger"
error_message = "Logger: " + record.getMessage()
file_path = record.pathname
line = str(record.lineno)
# Find visitor IP
x_forwarded_for = record.request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
visitor_ip = x_forwarded_for.split(',')[0]
else:
visitor_ip = record.request.META.get('REMOTE_ADDR')
# prepare request
payload = {
"application" : self.APPLICATION,
"version_complete" : self.VERSION_COMPLETE,
"version" : self.VERSION,
"build" : self.BUILD,
"date" : strftime("%Y-%m-%d %H:%M:%S"),
"gmdate" : strftime("%Y-%m-%d %H:%M:%S", gmtime()),
"visitor_ip" : visitor_ip,
"referrer_url" : record.request.META.get("HTTP_REFERER", ""),
"request_uri" : record.request.path,
"user_agent" : record.request.META.get("HTTP_USER_AGENT", ""),
"error_type" : error_type,
"error_message" : error_message,
"error_no" : 500,
"file" : file_path,
"line" : line,
"trace" : frames,
"additional_info" : reporter.get_traceback_text(),
}
# Optionally, you may provide a custom hash of the error that Snowy will
# use to determine if it's a duplicate or not. By default, Snowy hashes
# the application, error number, and error message and if that hash
# matches existing errors, we append the error to that issue instead of
# making a new one.
# You may provide your own custom hash that we'll check against your
# existing issues. The hash may be up to 255 characters long.
# For example, this will require errors come from the same application,
# file, and exact line.
payload['hash'] = sha1(self.APPLICATION + file_path + line).hexdigest()
params = {
'payload' : json.dumps(payload),
'api_key' : self.API_KEY,
'project_id' : self.PROJECT_ID,
}
# post
urllib.urlopen(self.SNOWY_ERROR_URL, urllib.urlencode(params))
def create_from_exception(self, exc_info=None, **kwargs):
"""
Creates an error log from an exception.
"""
if not exc_info:
exc_info = sys.exc_info()
exc_type, exc_value, exc_traceback = exc_info
def to_unicode(f):
if isinstance(f, dict):
nf = dict()
for k, v in f.iteritems():
nf[str(k)] = to_unicode(v)
f = nf
elif isinstance(f, (list, tuple)):
f = [to_unicode(f) for f in f]
else:
try:
f = smart_unicode(f)
except (UnicodeEncodeError, UnicodeDecodeError):
f = '(Error decoding value)'
except Exception: # in some cases we get a different exception
f = smart_unicode(type(f))
return f
def shorten(var):
if not isinstance(var, basestring):
var = to_unicode(var)
if len(var) > 500:
var = var[:500] + '...'
return var
reporter = ExceptionReporter(None, exc_type, exc_value, exc_traceback)
frames = varmap(shorten, reporter.get_traceback_frames())
if not kwargs.get('view'):
modules = get_installed_apps()
def iter_tb_frames(tb):
while tb:
yield tb.tb_frame
tb = tb.tb_next
for frame in iter_tb_frames(exc_traceback):
if frame.f_globals['__name__'].rsplit('.', 1)[0] in modules:
break
kwargs['view'] = '%s.%s' % (frame.f_globals['__name__'], frame.f_code.co_name)
data = kwargs.pop('data', {}) or {}
data['__sentry__'] = {
'exc': map(to_unicode, [exc_type.__class__.__module__, exc_value.args, frames]),
}
if isinstance(exc_value, TemplateSyntaxError) and hasattr(exc_value, 'source'):
origin, (start, end) = exc_value.source
data['__sentry__'].update({
'template': (origin.reload(), start, end, origin.name),
})
tb_message = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
kwargs.setdefault('message', to_unicode(exc_value))
return self.process(
class_name=exc_type.__name__,
traceback=tb_message,
data=data,
**kwargs
)