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