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, 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 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
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
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 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 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
)
