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': conf.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 process(self, **kwargs): from sentry.helpers import get_filters kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', conf.NAME) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name') or '', checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except (KeyError, ValueError): # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > conf.THRASHING_LIMIT: return for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # Make sure all additional data is coerced if 'data' in kwargs: kwargs['data'] = transform(kwargs['data']) return self.send(**kwargs)
def process(self, **kwargs): from sentry.helpers import get_filters for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) checksum = construct_checksum(**kwargs) if settings.THRASHING_TIMEOUT and settings.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name'), checksum) added = cache.add(cache_key, 1, settings.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except ValueError: # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > settings.THRASHING_LIMIT: return return self.send(**kwargs)
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 = 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", conf.CLIENT) site = kwargs.pop("site", None) data = kwargs.pop("data", {}) or {} if url: data["url"] = url url = url[:URL_MAX_LENGTH] checksum = construct_checksum(**kwargs) mail = False try: group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, defaults=kwargs ) if not created: GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F("times_seen") + 1, status=0, last_seen=now ) # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: mail = True instance = Message.objects.create( view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, **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 process(self, **kwargs): from sentry.helpers import get_filters kwargs.setdefault("level", logging.ERROR) kwargs.setdefault("server_name", conf.NAME) checksum = construct_checksum(**kwargs) if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = "sentry:%s:%s" % (kwargs.get("class_name") or "", checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) try: if not added and cache.incr(cache_key) > conf.THRASHING_LIMIT: return except KeyError: pass for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # Make sure all additional data is coerced if "data" in kwargs: kwargs["data"] = transform(kwargs["data"]) return self.send(**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': conf.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 process(self, **kwargs): from sentry.helpers import get_filters kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', conf.NAME) if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name') or '', checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) try: if not added and cache.incr(cache_key) > conf.THRASHING_LIMIT: return except KeyError: pass for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # Make sure all additional data is coerced if 'data' in kwargs: kwargs['data'] = transform(kwargs['data']) return self.send(**kwargs)
def process(self, **kwargs): from sentry.helpers import get_filters for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', socket.gethostname()) checksum = construct_checksum(**kwargs) if settings.THRASHING_TIMEOUT and settings.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name'), checksum) added = cache.add(cache_key, 1, settings.THRASHING_TIMEOUT) if not added and cache.incr(cache_key) > settings.THRASHING_LIMIT: return if settings.REMOTE_URL: data = { 'data': base64.b64encode(pickle.dumps(transform(kwargs)).encode('zlib')), 'key': settings.KEY, } req = urllib2.Request(settings.REMOTE_URL, urllib.urlencode(data)) try: response = urllib2.urlopen(req, None, settings.REMOTE_TIMEOUT).read() except urllib2.URLError, e: logger.exception('Unable to reach Sentry log server') except urllib2.HTTPError, e: logger.exception('Unable to reach Sentry log server', extra={'body': e.read()})
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 = 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) data = kwargs.pop('data', {}) or {} if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = construct_checksum(**kwargs) mail = False try: group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, defaults=kwargs ) if not created: GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=now, ) # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: mail = True instance = Message.objects.create( view=view, logger=logger_name, data=data, url=url, server_name=server_name, checksum=checksum, group=group, **kwargs ) FilterValue.objects.get_or_create(key='server_name', value=server_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 process(self, **kwargs): from sentry.helpers import get_filters kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', conf.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 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 for m in module_list: if m in versions: version = versions[m] # store our "best guess" for application version if version: kwargs['data']['__sentry__']['version'] = version if 'checksum' not in kwargs: checksum = construct_checksum(**kwargs) else: checksum = kwargs['checksum'] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name') or '', checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except (KeyError, ValueError): # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > conf.THRASHING_LIMIT: return for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # Make sure all data is coerced kwargs = transform(kwargs) return self.send(**kwargs)
def _create(self, **defaults): from models import Message, GroupedMessage URL_MAX_LENGTH = Message._meta.get_field_by_name('url')[0].max_length view = defaults.pop('view', None) logger_name = defaults.pop('logger', 'root') url = defaults.pop('url', None) data = defaults.pop('data', {}) or {} if url: data['url'] = url url = url[:URL_MAX_LENGTH] instance = Message( view=view, logger=logger_name, data=data, url=url, server_name=socket.gethostname(), **defaults ) instance.checksum = construct_checksum(instance) if settings.THRASHING_TIMEOUT and settings.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (instance.class_name, instance.checksum) added = cache.add(cache_key, 1, settings.THRASHING_TIMEOUT) if not added and cache.incr(cache_key) > settings.THRASHING_LIMIT: return try: group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=instance.checksum, defaults=defaults ) if not created: GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=datetime.datetime.now(), ) instance.group = group instance.save() 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_record(self, record, **kwargs): """ Creates an error log for a `logging` module `record` instance. """ for k in ('url', 'view', 'data'): if k not in kwargs: kwargs[k] = record.__dict__.get(k) request = getattr(record, 'request', None) if request: if not kwargs.get('data'): kwargs['data'] = {} kwargs['data'].update(dict( META=request.META, POST=request.POST, GET=request.GET, COOKIES=request.COOKIES, raw_post_data=request.raw_post_data, )) if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.update({ 'logger': record.name, 'level': record.levelno, 'message': force_unicode(record.msg), 'server_name': conf.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 process(self, **kwargs): from sentry.helpers import get_filters for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs kwargs.setdefault("level", logging.ERROR) kwargs.setdefault("server_name", settings.NAME) checksum = construct_checksum(**kwargs) if settings.THRASHING_TIMEOUT and settings.THRASHING_LIMIT: cache_key = "sentry:%s:%s" % (kwargs.get("class_name"), checksum) added = cache.add(cache_key, 1, settings.THRASHING_TIMEOUT) if not added and cache.incr(cache_key) > settings.THRASHING_LIMIT: return return self.send(**kwargs)
def process(self, **kwargs): from sentry.helpers import get_filters kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', settings.NAME) checksum = construct_checksum(**kwargs) if settings.THRASHING_TIMEOUT and settings.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name'), checksum) added = cache.add(cache_key, 1, settings.THRASHING_TIMEOUT) if not added and cache.incr(cache_key) > settings.THRASHING_LIMIT: return for filter_ in get_filters(): kwargs = filter_(None).process(kwargs) or kwargs # Make sure all additional data is coerced if 'data' in kwargs: kwargs['data'] = transform(kwargs['data']) return self.send(**kwargs)
def create_from_record(self, record, **kwargs): """ Creates an error log for a `logging` module `record` instance. """ for k in ("url", "view", "data"): if k not in kwargs: kwargs[k] = record.__dict__.get(k) request = getattr(record, "request", None) if request: if not kwargs.get("data"): kwargs["data"] = {} kwargs["data"].update(dict(META=request.META, POST=request.POST, GET=request.GET, COOKIES=request.COOKIES)) if not kwargs.get("url"): kwargs["url"] = request.build_absolute_uri() kwargs.update( { "logger": record.name, "level": record.levelno, "message": force_unicode(record.msg), "server_name": conf.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 process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.helpers 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, REQUEST_USER=request.user, )) if not kwargs.get('url'): kwargs['url'] = request.build_absolute_uri() kwargs.setdefault('level', logging.ERROR) kwargs.setdefault('server_name', conf.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'] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name') or '', checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except (KeyError, ValueError): # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > conf.THRASHING_LIMIT: message_id = cache.get('%s:last_message_id' % cache_key) if request: # 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 = transform(kwargs) self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': message_id, } if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: # store the last message_id incase we hit thrashing limits cache.set('%s:last_message_id' % cache_key, message_id, conf.THRASHING_LIMIT+5) return message_id
def process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.helpers 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"] = {} kwargs["data"].update(dict(META=request.META, POST=request.POST, 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", conf.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 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"] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = "sentry:%s:%s" % (kwargs.get("class_name") or "", checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except (KeyError, ValueError): # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > conf.THRASHING_LIMIT: message_id = cache.get("%s:last_message_id" % cache_key) if request: # 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 = transform(kwargs) self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = {"id": message_id} if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: # store the last message_id incase we hit thrashing limits cache.set("%s:last_message_id" % cache_key, message_id, conf.THRASHING_LIMIT + 5) 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 = timezone.now() view = kwargs.pop('view', None) logger_name = kwargs.pop('logger', 'root') url = kwargs.pop('url', None) server_name = kwargs.pop('server_name', conf.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, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, # we store some sample data for rendering defaults=kwargs ) kwargs.pop('data', None) if not created: GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=now, ) # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: 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, **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 save(self, *args, **kwargs): if not self.checksum: self.checksum = construct_checksum(**self.__dict__) super(Message, self).save(*args, **kwargs)
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 = 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', conf.CLIENT) site = kwargs.pop('site', None) request_user = kwargs.pop('request_user', 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, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, # we store some sample data for rendering defaults=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, request_user=request_user, checksum=checksum, group=group, **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 request_user: FilterValue.objects.get_or_create(key='request_user', value=request_user) 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 = 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 {} if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = construct_checksum(**kwargs) mail = False try: group, created = GroupedMessage.objects.get_or_create( view=view, logger=logger_name, checksum=checksum, defaults=kwargs) if not created: GroupedMessage.objects.filter(pk=group.pk).update( times_seen=models.F('times_seen') + 1, status=0, last_seen=now, ) # HACK: maintain appeared state if group.status == 1: mail = True group.status = 0 group.last_seen = now group.times_seen += 1 signals.post_save.send(sender=GroupedMessage, instance=group, created=False) else: mail = True instance = Message.objects.create(view=view, logger=logger_name, data=data, url=url, server_name=server_name, site=site, checksum=checksum, group=group, **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 process(self, **kwargs): "Processes the message before passing it on to the server" from sentry.helpers 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'] = {} kwargs['data'].update( dict( META=request.META, POST=request.POST, 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', conf.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 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'] if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: cache_key = 'sentry:%s:%s' % (kwargs.get('class_name') or '', checksum) added = cache.add(cache_key, 1, conf.THRASHING_TIMEOUT) if not added: try: thrash_count = cache.incr(cache_key) except (KeyError, ValueError): # cache.incr can fail. Assume we aren't thrashing yet, and # if we are, hope that the next error has a successful # cache.incr call. thrash_count = 0 if thrash_count > conf.THRASHING_LIMIT: message_id = cache.get('%s:last_message_id' % cache_key) if request: # 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 = transform(kwargs) self.send(**kwargs) if request: # attach the sentry object to the request request.sentry = { 'id': message_id, } if conf.THRASHING_TIMEOUT and conf.THRASHING_LIMIT: # store the last message_id incase we hit thrashing limits cache.set('%s:last_message_id' % cache_key, message_id, conf.THRASHING_LIMIT + 5) 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 name = kwargs.pop('name', None) message_type = kwargs.pop("message_type", conf.LOG) project = kwargs.pop("project") site = kwargs.pop('site', None) test_result = kwargs.pop('test_result', None) # Log specific logger_name = kwargs.pop('logger', '') url = kwargs.pop('url', None) data = kwargs.pop('data', {}) or {} if url: data['url'] = url url = url[:URL_MAX_LENGTH] checksum = construct_checksum(**kwargs) mail = False try: if 'url' in data: kwargs['data'] = {'url': data['url']} group, created = self._get_or_create_group_message(message_type, name, checksum, project, test_result, kwargs) kwargs.pop('data', None) if not created: self._update_counters(group) else: mail = True instance = Message.objects.create( name=name, message_type=message_type, project=project, checksum=checksum, group=group, logger=logger_name, data=data, url=url, site=site, test_result=test_result, **kwargs ) if site: print FilterValue.objects.all() FilterValue.objects.get_or_create(key='site__servername', value=site.servername, label=site.servername) # if site: # FilterValue.objects.get_or_create(key='site', value=site.id, label=site.name) if site: FilterValue.objects.get_or_create(key='project', value=project.id, label=project.name) if logger_name: FilterValue.objects.get_or_create(key='logger', value=logger_name, label=logger_name) if test_result: FilterValue.objects.get_or_create(key='test_result', value=test_result, label=test_result) 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,))