def sentry_exception_handler(sender, request=None, **kwargs): try: exc_type, exc_value, exc_traceback = sys.exc_info() if not settings.CATCH_404_ERRORS \ and issubclass(exc_type, Http404): return if dj_settings.DEBUG or getattr(exc_type, 'skip_sentry', False): return if transaction.is_dirty(): transaction.rollback() # kudos to Tapz for this idea modules = get_installed_apps() # only retrive last 10 lines tb = traceback.extract_tb(exc_traceback) # retrive final file and line number where the exception occured file, line_number = tb[-1][:2] # tiny hack to get the python path from filename for (filename, line, function, text) in reversed(tb): for path in sys.path: if filename.startswith(path): view = '%s.%s' % (filename[len(path)+1:].replace('/', '.').replace('.py', ''), function) break if view.split('.')[0] in modules: break else: view = '%s.%s' % (exc_traceback.tb_frame.f_globals['__name__'], tb[-1][2]) if request: data = dict( META=request.META, POST=request.POST, GET=request.GET, COOKIES=request.COOKIES, ) else: data = dict() extra = dict( url=request and request.build_absolute_uri() or None, data=data, view=view, ) if settings.USE_LOGGING: logger.critical(exc_value, exc_info=sys.exc_info(), extra=extra) else: SentryClient.create_from_exception(**extra) except Exception, exc: try: logger.exception(u'Unable to process log entry: %s' % (exc,)) except Exception, exc: warnings.warn(u'Unable to process log entry: %s' % (exc,))
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 )