def create_from_record(self, record, **kwargs): """ Creates an error log for a ``logging`` module ``record`` instance. """ for k in ('url', 'view', 'request', 'data'): if not kwargs.get(k): kwargs[k] = record.__dict__.get(k) kwargs.update({ 'logger': record.name, 'level': record.levelno, 'message': force_unicode(record.msg), 'server_name': settings.NAME, }) # construct the checksum with the unparsed message kwargs['checksum'] = construct_checksum(**kwargs) # save the message with included formatting kwargs['message'] = record.getMessage() # If there's no exception being processed, exc_info may be a 3-tuple of None # http://docs.python.org/library/sys.html#sys.exc_info if record.exc_info and all(record.exc_info): return self.create_from_exception(record.exc_info, **kwargs) return self.process( traceback=record.exc_text, **kwargs )
def create_from_record(self, record, **kwargs): """ Creates an error log for a ``logging`` module ``record`` instance. """ for k in ('url', 'view', 'request', 'data'): if not kwargs.get(k): kwargs[k] = record.__dict__.get(k) kwargs.update({ 'logger': record.name, 'level': record.levelno, 'message': force_unicode(record.msg), 'server_name': settings.NAME, }) # construct the checksum with the unparsed message kwargs['checksum'] = construct_checksum(**kwargs) # save the message with included formatting kwargs['message'] = record.getMessage() # If there's no exception being processed, exc_info may be a 3-tuple of None # http://docs.python.org/library/sys.html#sys.exc_info if record.exc_info and all(record.exc_info): return self.create_from_exception(record.exc_info, **kwargs) return self.process(traceback=record.exc_text, **kwargs)
def create_from_record(self, record, **kwargs): """ Creates an error log for a ``logging`` module ``record`` instance. """ for k in ('url', 'view', 'request', 'data'): if not kwargs.get(k): kwargs[k] = record.__dict__.get(k) kwargs.update({ 'logger': record.name, 'level': record.levelno, 'message': force_unicode(record.msg), 'server_name': settings.NAME, }) # construct the checksum with the unparsed message kwargs['checksum'] = construct_checksum(**kwargs) # save the message with included formatting kwargs['message'] = record.getMessage() # If there's no exception being processed, exc_info may be a 3-tuple of None # http://docs.python.org/library/sys.html#sys.exc_info if record.exc_info and all(record.exc_info): return self.create_from_exception(record.exc_info, **kwargs) data = kwargs.pop('data', {}) or {} data['__sentry__'] = {} if getattr(record, 'stack', settings.AUTO_LOG_STACKS): stack = [] found = None for frame in iter_stack_frames(): # There are initial frames from Sentry that need skipped name = frame.f_globals.get('__name__') if found is None: if name == 'logging': found = False continue elif not found: if name != 'logging': found = True else: continue stack.append(frame) data['__sentry__']['frames'] = varmap(shorten, get_stack_info(stack)) return self.process( traceback=record.exc_text, data=data, **kwargs )
def process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.utils import get_filters if kwargs.get('data'): # Ensure we're not changing the original data which was passed # to Sentry kwargs['data'] = kwargs['data'].copy() request = kwargs.pop('request', None) if request: if not kwargs.get('data'): kwargs['data'] = {} if not request.POST and request.raw_post_data: post_data = request.raw_post_data else: post_data = request.POST kwargs['data'].update(dict( META=request.META, POST=post_data, GET=request.GET, COOKIES=request.COOKIES, )) if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) # save versions of all installed apps if 'data' not in kwargs or '__sentry__' not in (kwargs['data'] or {}): if kwargs.get('data') is None: kwargs['data'] = {} kwargs['data']['__sentry__'] = {} versions = get_versions() kwargs['data']['__sentry__']['versions'] = versions # Shorten lists/strings for k, v in kwargs['data'].iteritems(): if k == '__sentry__': continue kwargs['data'][k] = shorten(v) if kwargs.get('view'): # get list of modules from right to left parts = kwargs['view'].split('.') module_list = ['.'.join(parts[:idx]) for idx in xrange(1, len(parts)+1)][::-1] version = None module = None for m in module_list: if m in versions: module = m version = versions[m] # store our "best guess" for application version if version: kwargs['data']['__sentry__'].update({ 'version': version, 'module': module, }) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] (is_thrashing, message_id) = self.check_throttle(checksum) if is_thrashing: if request and message_id: # attach the sentry object to the request request.sentry = { 'id': message_id, 'thrashed': True, } return message_id for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # create ID client-side so that it can be passed to application message_id = uuid.uuid4().hex kwargs['message_id'] = message_id # Make sure all data is coerced kwargs['data'] = transform(kwargs['data']) if 'timestamp' not in kwargs: kwargs['timestamp'] = datetime.datetime.now() self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': message_id, 'trashed': False, } # store the last message_id incase we hit thrashing limits self.set_last_message_id(checksum, message_id) return message_id
def from_kwargs(self, **kwargs): from sentry.models import Message, GroupedMessage, FilterValue URL_MAX_LENGTH = Message._meta.get_field_by_name('url')[0].max_length now = kwargs.pop('timestamp', None) or datetime.datetime.now() view = kwargs.pop('view', None) logger_name = kwargs.pop('logger', 'root') url = kwargs.pop('url', None) server_name = kwargs.pop('server_name', settings.CLIENT) site = kwargs.pop('site', None) data = kwargs.pop('data', {}) or {} message_id = kwargs.pop('message_id', None) if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = kwargs.pop('checksum', None) if not checksum: checksum = construct_checksum(**kwargs) mail = False try: kwargs['data'] = {} if 'url' in data: kwargs['data']['url'] = data['url'] if 'version' in data.get('__sentry__', {}): kwargs['data']['version'] = data['__sentry__']['version'] if 'module' in data.get('__sentry__', {}): kwargs['data']['module'] = data['__sentry__']['module'] group_kwargs = kwargs.copy() group_kwargs.update({ 'last_seen': now, 'first_seen': now, }) group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, # we store some sample data for rendering defaults=group_kwargs ) kwargs.pop('data', None) if not created: # HACK: maintain appeared state if group.status == 1: mail = True silence_timedelta = now - group.last_seen silence = silence_timedelta.days * 86400 + silence_timedelta.seconds group.status = 0 group.last_seen = now group.times_seen += 1 GroupedMessage.objects.filter(pk=group.pk).update( times_seen=F('times_seen') + 1, status=0, last_seen=now, score=ScoreClause(group), ) signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: GroupedMessage.objects.filter(pk=group.pk).update( score=ScoreClause(group), ) silence = 0 mail = True instance = Message( message_id=message_id, view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, datetime=now, **kwargs ) if not settings.SAMPLE_DATA or group.times_seen % min(count_limit(group.times_seen), time_limit(silence)) == 0: instance.save() # rounded down to the nearest interval if settings.MINUTE_NORMALIZATION: minutes = (now.minute - (now.minute % settings.MINUTE_NORMALIZATION)) else: minutes = now.minute normalized_datetime = now.replace(second=0, microsecond=0, minute=minutes) try: affected = group.messagecountbyminute_set.filter(date=normalized_datetime).update(times_seen=F('times_seen') + 1) if not affected: group.messagecountbyminute_set.create( date=normalized_datetime, times_seen=1, ) for key, value in ( ('server_name', server_name), ('site', site), ('logger', logger_name), ): if not value: continue FilterValue.objects.get_or_create(key=key, value=value) affected = group.messagefiltervalue_set.filter(key=key, value=value).update(times_seen=F('times_seen') + 1) if not affected: group.messagefiltervalue_set.create( key=key, value=value, times_seen=1, ) except Exception: return instance except Exception, exc: # TODO: should we mail admins when there are failures? 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 save(self, *args, **kwargs): if not self.checksum: self.checksum = construct_checksum(**self.__dict__) super(Message, self).save(*args, **kwargs)
def process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.utils import get_filters if kwargs.get('data'): # Ensure we're not changing the original data which was passed # to Sentry kwargs['data'] = kwargs['data'].copy() else: kwargs['data'] = {} if '__sentry__' not in kwargs['data']: kwargs['data']['__sentry__'] = {} request = kwargs.pop('request', None) if isinstance(request, HttpRequest): try: post_data = not request.POST and request.raw_post_data or request.POST except: post_data = request.POST kwargs['data'].update(dict( META=request.META, POST=post_data, GET=request.GET, COOKIES=request.COOKIES, )) if hasattr(request, 'user'): if request.user.is_authenticated(): user_info = { 'is_authenticated': True, 'id': request.user.pk, 'username': request.user.username, 'email': request.user.email, } else: user_info = { 'is_authenticated': False, } kwargs['data']['__sentry__']['user'] = user_info if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) versions = get_versions() kwargs['data']['__sentry__']['versions'] = versions # Shorten lists/strings for k, v in kwargs['data'].iteritems(): if k == '__sentry__': continue kwargs['data'][k] = shorten(v) # if we've passed frames, lets try to fetch the culprit if not kwargs.get('view') and kwargs['data']['__sentry__'].get('frames'): # This should be cached modules = get_installed_apps() if settings.INCLUDE_PATHS: modules = set(list(modules) + settings.INCLUDE_PATHS) 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 kwargs['data']['__sentry__']['frames']: try: view = '.'.join([frame['module'], frame['function']]) except: continue 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 if view: kwargs['view'] = view # try to fetch the current version if kwargs.get('view'): # get list of modules from right to left parts = kwargs['view'].split('.') module_list = ['.'.join(parts[:idx]) for idx in xrange(1, len(parts) + 1)][::-1] version = None module = None for m in module_list: if m in versions: module = m version = versions[m] # store our "best guess" for application version if version: kwargs['data']['__sentry__'].update({ 'version': version, 'module': module, }) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] (is_thrashing, message_id) = self.check_throttle(checksum) if is_thrashing: if request and message_id: # attach the sentry object to the request request.sentry = { 'id': '%s$%s' % (message_id, checksum), 'thrashed': True, } return message_id for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # create ID client-side so that it can be passed to application message_id = uuid.uuid4().hex kwargs['message_id'] = message_id # Make sure all data is coerced kwargs['data'] = transform(kwargs['data']) if 'timestamp' not in kwargs: kwargs['timestamp'] = datetime.datetime.now() self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': '%s$%s' % (message_id, checksum), 'thrashed': False, } # store the last message_id incase we hit thrashing limits self.set_last_message_id(checksum, message_id) return message_id
def from_kwargs(self, **kwargs): from sentry.models import Message, GroupedMessage, FilterValue URL_MAX_LENGTH = Message._meta.get_field_by_name('url')[0].max_length now = kwargs.pop('timestamp', None) or datetime.datetime.now() view = kwargs.pop('view', None) logger_name = kwargs.pop('logger', 'root') url = kwargs.pop('url', None) server_name = kwargs.pop('server_name', settings.CLIENT) site = kwargs.pop('site', None) data = kwargs.pop('data', {}) or {} message_id = kwargs.pop('message_id', None) if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = kwargs.pop('checksum', None) if not checksum: checksum = construct_checksum(**kwargs) mail = False try: kwargs['data'] = {} if 'url' in data: kwargs['data']['url'] = data['url'] if 'version' in data.get('__sentry__', {}): kwargs['data']['version'] = data['__sentry__']['version'] if 'module' in data.get('__sentry__', {}): kwargs['data']['module'] = data['__sentry__']['module'] group_kwargs = kwargs.copy() group_kwargs.update({ 'last_seen': now, 'first_seen': now, }) group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, # we store some sample data for rendering defaults=group_kwargs ) kwargs.pop('data', None) if not created: # HACK: maintain appeared state if group.status == 1: mail = True silence_timedelta = now - group.last_seen silence = silence_timedelta.days * 86400 + silence_timedelta.seconds group.status = 0 group.last_seen = now group.times_seen += 1 GroupedMessage.objects.filter(pk=group.pk).update( times_seen=F('times_seen') + 1, status=0, last_seen=now, score=ScoreClause(group), ) signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: GroupedMessage.objects.filter(pk=group.pk).update( score=ScoreClause(group), ) silence = 0 mail = True instance = Message( message_id=message_id, view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, datetime=now, **kwargs ) if not settings.SAMPLE_DATA or group.times_seen % min(count_limit(group.times_seen), time_limit(silence)) == 0: instance.save() # rounded down to the nearest interval if settings.MINUTE_NORMALIZATION: minutes = (now.minute - (now.minute % settings.MINUTE_NORMALIZATION)) else: minutes = now.minute normalized_datetime = now.replace(second=0, microsecond=0, minute=minutes) affected = group.messagecountbyminute_set.filter(date=normalized_datetime).update(times_seen=F('times_seen') + 1) if not affected: group.messagecountbyminute_set.create( date=normalized_datetime, times_seen=1, ) for key, value in ( ('server_name', server_name), ('site', site), ('logger', logger_name), ): if not value: continue FilterValue.objects.get_or_create(key=key, value=value) affected = group.messagefiltervalue_set.filter(key=key, value=value).update(times_seen=F('times_seen') + 1) if not affected: group.messagefiltervalue_set.create( key=key, value=value, times_seen=1, ) except Exception, exc: # TODO: should we mail admins when there are failures? 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 process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.utils import get_filters if kwargs.get('data'): # Ensure we're not changing the original data which was passed # to Sentry kwargs['data'] = kwargs['data'].copy() request = kwargs.pop('request', None) if request: if not kwargs.get('data'): kwargs['data'] = {} if not request.POST and request.raw_post_data: post_data = request.raw_post_data else: post_data = request.POST kwargs['data'].update( dict( META=request.META, POST=post_data, GET=request.GET, COOKIES=request.COOKIES, )) if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) # save versions of all installed apps if 'data' not in kwargs or '__sentry__' not in (kwargs['data'] or {}): if kwargs.get('data') is None: kwargs['data'] = {} kwargs['data']['__sentry__'] = {} versions = get_versions() kwargs['data']['__sentry__']['versions'] = versions # Shorten lists/strings for k, v in kwargs['data'].iteritems(): if k == '__sentry__': continue kwargs['data'][k] = shorten(v) if kwargs.get('view'): # get list of modules from right to left parts = kwargs['view'].split('.') module_list = [ '.'.join(parts[:idx]) for idx in xrange(1, len(parts) + 1) ][::-1] version = None module = None for m in module_list: if m in versions: module = m version = versions[m] # store our "best guess" for application version if version: kwargs['data']['__sentry__'].update({ 'version': version, 'module': module, }) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] (is_thrashing, message_id) = self.check_throttle(checksum) if is_thrashing: if request and message_id: # attach the sentry object to the request request.sentry = { 'id': message_id, 'thrashed': True, } return message_id for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # create ID client-side so that it can be passed to application message_id = uuid.uuid4().hex kwargs['message_id'] = message_id # Make sure all data is coerced kwargs['data'] = transform(kwargs['data']) if 'timestamp' not in kwargs: kwargs['timestamp'] = datetime.datetime.now() self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': message_id, 'trashed': False, } # store the last message_id incase we hit thrashing limits self.set_last_message_id(checksum, message_id) return message_id
def process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.utils import get_filters if kwargs.get('data'): # Ensure we're not changing the original data which was passed # to Sentry kwargs['data'] = kwargs['data'].copy() else: kwargs['data'] = {} if '__sentry__' not in kwargs['data']: kwargs['data']['__sentry__'] = {} request = kwargs.pop('request', None) if isinstance(request, HttpRequest): try: post_data = not request.POST and request.raw_post_data or request.POST except: post_data = request.POST kwargs['data'].update( dict( META=request.META, POST=post_data, GET=request.GET, COOKIES=request.COOKIES, )) if hasattr(request, 'user'): if request.user.is_authenticated(): user_info = { 'is_authenticated': True, 'id': request.user.pk, 'username': request.user.username, 'email': request.user.email, } else: user_info = { 'is_authenticated': False, } kwargs['data']['__sentry__']['user'] = user_info if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) versions = get_versions() kwargs['data']['__sentry__']['versions'] = versions # Shorten lists/strings for k, v in kwargs['data'].iteritems(): if k == '__sentry__': continue kwargs['data'][k] = shorten(v) # if we've passed frames, lets try to fetch the culprit if not kwargs.get('view') and kwargs['data']['__sentry__'].get( 'frames'): # This should be cached modules = get_installed_apps() if settings.INCLUDE_PATHS: modules = set(list(modules) + settings.INCLUDE_PATHS) 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 kwargs['data']['__sentry__']['frames']: try: view = '.'.join([frame['module'], frame['function']]) except: continue 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 if view: kwargs['view'] = view # try to fetch the current version if kwargs.get('view'): # get list of modules from right to left parts = kwargs['view'].split('.') module_list = [ '.'.join(parts[:idx]) for idx in xrange(1, len(parts) + 1) ][::-1] version = None module = None for m in module_list: if m in versions: module = m version = versions[m] # store our "best guess" for application version if version: kwargs['data']['__sentry__'].update({ 'version': version, 'module': module, }) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] (is_thrashing, message_id) = self.check_throttle(checksum) if is_thrashing: if request and message_id: # attach the sentry object to the request request.sentry = { 'id': '%s$%s' % (message_id, checksum), 'thrashed': True, } return message_id for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # create ID client-side so that it can be passed to application message_id = uuid.uuid4().hex kwargs['message_id'] = message_id # Make sure all data is coerced kwargs['data'] = transform(kwargs['data']) if 'timestamp' not in kwargs: kwargs['timestamp'] = datetime.datetime.now() self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': '%s$%s' % (message_id, checksum), 'thrashed': False, } # store the last message_id incase we hit thrashing limits self.set_last_message_id(checksum, message_id) return message_id
def process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.utils import get_filters if kwargs.get("data"): # Ensure we're not changing the original data which was passed # to Sentry kwargs["data"] = kwargs["data"].copy() else: kwargs["data"] = {} if "__sentry__" not in kwargs["data"]: kwargs["data"]["__sentry__"] = {} request = kwargs.pop("request", None) if isinstance(request, HttpRequest): if not request.POST and request.body: post_data = request.body else: post_data = request.POST kwargs["data"].update(dict(META=request.META, POST=post_data, GET=request.GET, COOKIES=request.COOKIES)) if hasattr(request, "user"): if request.user.is_authenticated(): user_info = { "is_authenticated": True, "id": request.user.pk, "username": request.user.username, "email": request.user.email, } else: user_info = {"is_authenticated": False} kwargs["data"]["__sentry__"]["user"] = user_info if not kwargs.get("url"): kwargs["url"] = request.build_absolute_uri() kwargs.setdefault("level", logging.ERROR) kwargs.setdefault("server_name", settings.NAME) versions = get_versions() kwargs["data"]["__sentry__"]["versions"] = versions # Shorten lists/strings for k, v in kwargs["data"].iteritems(): if k == "__sentry__": continue kwargs["data"][k] = shorten(v) # if we've passed frames, lets try to fetch the culprit if not kwargs.get("view") and kwargs["data"]["__sentry__"].get("frames"): # This should be cached modules = get_installed_apps() if settings.INCLUDE_PATHS: modules = set(list(modules) + settings.INCLUDE_PATHS) 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 kwargs["data"]["__sentry__"]["frames"]: try: view = ".".join([frame["module"], frame["function"]]) except: continue 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 if view: kwargs["view"] = view # try to fetch the current version if kwargs.get("view"): # get list of modules from right to left parts = kwargs["view"].split(".") module_list = [".".join(parts[:idx]) for idx in xrange(1, len(parts) + 1)][::-1] version = None module = None for m in module_list: if m in versions: module = m version = versions[m] # store our "best guess" for application version if version: kwargs["data"]["__sentry__"].update({"version": version, "module": module}) if "checksum" not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs["checksum"] (is_thrashing, message_id) = self.check_throttle(checksum) if is_thrashing: if request and message_id: # attach the sentry object to the request request.sentry = {"id": message_id, "thrashed": True} return message_id for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # create ID client-side so that it can be passed to application message_id = uuid.uuid4().hex kwargs["message_id"] = message_id # Make sure all data is coerced kwargs["data"] = transform(kwargs["data"]) if "timestamp" not in kwargs: kwargs["timestamp"] = now_with_tz_if_supported() self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = {"id": message_id, "thrashed": False} # store the last message_id incase we hit thrashing limits self.set_last_message_id(checksum, message_id) return message_id
def from_kwargs(self, **kwargs): from sentry.models import Message, GroupedMessage, FilterValue URL_MAX_LENGTH = Message._meta.get_field_by_name('url')[0].max_length now = kwargs.pop('timestamp', None) or datetime.datetime.now() view = kwargs.pop('view', None) logger_name = kwargs.pop('logger', 'root') url = kwargs.pop('url', None) server_name = kwargs.pop('server_name', settings.CLIENT) site = kwargs.pop('site', None) data = kwargs.pop('data', {}) or {} message_id = kwargs.pop('message_id', None) if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = kwargs.pop('checksum', None) if not checksum: checksum = construct_checksum(**kwargs) mail = False try: kwargs['data'] = {} if 'url' in data: kwargs['data']['url'] = data['url'] if 'version' in data.get('__sentry__', {}): kwargs['data']['version'] = data['__sentry__']['version'] if 'module' in data.get('__sentry__', {}): kwargs['data']['module'] = data['__sentry__']['module'] group_kwargs = kwargs.copy() group_kwargs.update({ 'last_seen': now, 'first_seen': now, }) gc_kwargs = dict(logger=logger_name, checksum=checksum, view=view) try: group_name = self._get_group_by_view(kwargs) except: group_name = None if group_name is not None: # if the message should be grouped use the group_name to select # existing groups (avoid more specific groups) gc_kwargs = dict(view=group_name) group_kwargs = {'class_name': kwargs.get("class_name"), 'checksum': checksum, 'logger':logger_name} group, created = GroupedMessage.objects.get_or_create( # we store some sample data for rendering defaults=group_kwargs, **gc_kwargs ) kwargs.pop('data', None) if not created: # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=now, score=ScoreClause(group), ) signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: GroupedMessage.objects.filter(pk=group.pk).update( score=ScoreClause(group), ) mail = True instance = Message.objects.create( message_id=message_id, view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, datetime=now, **kwargs ) if server_name: FilterValue.objects.get_or_create(key='server_name', value=server_name) if site: FilterValue.objects.get_or_create(key='site', value=site) if logger_name: FilterValue.objects.get_or_create(key='logger', value=logger_name) except Exception, exc: # TODO: should we mail admins when there are failures? 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 from_kwargs(self, **kwargs): from sentry.models import Message, GroupedMessage, FilterValue URL_MAX_LENGTH = Message._meta.get_field_by_name('url')[0].max_length now = kwargs.pop('timestamp', None) or datetime.datetime.now() view = kwargs.pop('view', None) logger_name = kwargs.pop('logger', 'root') url = kwargs.pop('url', None) server_name = kwargs.pop('server_name', settings.CLIENT) site = kwargs.pop('site', None) data = kwargs.pop('data', {}) or {} message_id = kwargs.pop('message_id', None) if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = kwargs.pop('checksum', None) if not checksum: checksum = construct_checksum(**kwargs) mail = False try: kwargs['data'] = {} if 'url' in data: kwargs['data']['url'] = data['url'] if 'version' in data.get('__sentry__', {}): kwargs['data']['version'] = data['__sentry__']['version'] if 'module' in data.get('__sentry__', {}): kwargs['data']['module'] = data['__sentry__']['module'] group_kwargs = kwargs.copy() group_kwargs.update({ 'last_seen': now, 'first_seen': now, }) group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, # we store some sample data for rendering defaults=group_kwargs) kwargs.pop('data', None) if not created: # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=now, score=ScoreClause(group), ) signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: GroupedMessage.objects.filter(pk=group.pk).update( score=ScoreClause(group), ) mail = True instance = Message.objects.create(message_id=message_id, view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, datetime=now, **kwargs) if server_name: FilterValue.objects.get_or_create(key='server_name', value=server_name) if site: FilterValue.objects.get_or_create(key='site', value=site) if logger_name: FilterValue.objects.get_or_create(key='logger', value=logger_name) except Exception, exc: # TODO: should we mail admins when there are failures? try: logger.exception(u'Unable to process log entry: %s' % (exc, )) except Exception, exc: warnings.warn(u'Unable to process log entry: %s' % (exc, ))