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 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 index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get('p', 1))
except (TypeError, ValueError):
page = 1
query = request.GET.get('content')
is_search = query
if is_search:
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) \
| Q(message__icontains=query) \
| Q(traceback__icontains=query)
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
if not is_search:
message_list = message_list.order_by('-score', '-last_seen')
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response('sentry/index.html', {
'has_realtime': has_realtime,
'message_list': message_list,
'today': today,
'query': query,
'sort': sort,
'any_filter': any_filter,
'request': request,
'filters': filters,
})
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 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 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 register_indexes():
"""
Grabs all required indexes from filters and registers them.
"""
logger = logging.getLogger('sentry.setup')
for filter_ in get_filters():
if filter_.column.startswith('data__'):
Index.objects.register_model(Message, filter_.column, index_to='group')
logger.debug('Registered index for for %s' % filter_.column)
def register_indexes():
"""
Grabs all required indexes from filters and registers them.
"""
logger = logging.getLogger('sentry.setup')
for filter_ in get_filters():
if filter_.column.startswith('data__'):
Index.objects.register_model(Message, filter_.column, index_to='group')
logger.debug('Registered index for for %s' % filter_.column)
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 index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get("p", 1))
except (TypeError, ValueError):
page = 1
message_list = GroupedMessage.objects.all()
sort = request.GET.get("sort")
if sort == "date":
message_list = message_list.order_by("-last_seen")
elif sort == "new":
message_list = message_list.order_by("-first_seen")
elif sort == "freq":
message_list = message_list.order_by("-times_seen")
else:
sort = "priority"
message_list = message_list.order_by("-score", "-last_seen")
# Filters only apply if we're not searching
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response(
"sentry/index.html",
{
"has_realtime": has_realtime,
"message_list": message_list,
"today": today,
"sort": sort,
"any_filter": any_filter,
"request": request,
"filters": filters,
},
)
def index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get('p', 1))
except (TypeError, ValueError):
page = 1
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
})
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
message_list = message_list.order_by('-score', '-last_seen')
# Filters only apply if we're not searching
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response(
'sentry/index.html', {
'has_realtime': has_realtime,
'message_list': message_list,
'today': today,
'sort': sort,
'any_filter': any_filter,
'request': request,
'filters': filters,
})
def index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get('p', 1))
except (TypeError, ValueError):
page = 1
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
message_list = message_list.order_by('-score', '-last_seen')
# Filters only apply if we're not searching
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response('sentry/index.html', {
'has_realtime': has_realtime,
'message_list': message_list,
'today': today,
'sort': sort,
'any_filter': any_filter,
'request': request,
'filters': filters,
})
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 index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get('p', 1))
except (TypeError, ValueError):
page = 1
# this only works in postgres
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
message_list = message_list.order_by('-score', '-last_seen')
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response('sentry/index.html', locals())
def index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get("p", 1))
except (TypeError, ValueError):
page = 1
# this only works in postgres
message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})
sort = request.GET.get("sort")
if sort == "date":
message_list = message_list.order_by("-last_seen")
elif sort == "new":
message_list = message_list.order_by("-first_seen")
else:
sort = "priority"
message_list = message_list.order_by("-score", "-last_seen")
any_filter = False
query = Q()
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
query &= filter_._get_query()
message_list = message_list.filter(query).distinct()
today = datetime.datetime.now()
has_realtime = page == 1
config = conf
return locals()
def ajax_handler(request):
op = request.REQUEST.get("op")
if op == "poll":
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})
sort = request.GET.get("sort")
if sort == "date":
message_list = message_list.order_by("-last_seen")
elif sort == "new":
message_list = message_list.order_by("-first_seen")
else:
sort = "priority"
message_list = message_list.order_by("-score", "-last_seen")
query = Q()
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
query &= filter_._get_query()
message_list = message_list.filter(query).distinct()
data = [
(
m.pk,
{
"html": render_to_string(
"sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
),
"count": m.times_seen,
"priority": p,
},
)
for m, p in with_priority(message_list[0:15])
]
elif op == "resolve":
gid = request.REQUEST.get("gid")
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(request.META["HTTP_REFERER"])
data = [
(
m.pk,
{
"html": render_to_string("sentry/partial/_group.html", {"group": m, "request": request}),
"count": m.times_seen,
},
)
for m in [group]
]
else:
return HttpResponseBadRequest()
response = HttpResponse(simplejson.dumps(data))
response["Content-Type"] = "application/json"
return response
def ajax_handler(request):
op = request.REQUEST.get('op')
if op == 'poll':
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
message_list = message_list.order_by('-score', '-last_seen')
for filter_ in filters:
if not filter_.is_set():
continue
message_list = filter_.get_query_set(message_list)
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'priority': p,
'request': request,
}),
'count': m.times_seen,
'priority': p,
}) for m, p in with_priority(message_list[0:15])]
elif op == 'resolve':
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(request.META['HTTP_REFERER'])
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}),
'count': m.times_seen,
}) for m in [group]]
else:
return HttpResponseBadRequest()
response = HttpResponse(simplejson.dumps(data))
response['Content-Type'] = 'application/json'
return response
def index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get('p', 1))
except (TypeError, ValueError):
page = 1
query = request.GET.get('content')
is_search = query
if is_search:
if uuid_re.match(query):
# Forward to message if it exists
try:
message = Message.objects.get(message_id=query)
except Message.DoesNotExist:
pass
else:
return HttpResponseRedirect(message.get_absolute_url())
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) \
| Q(message__icontains=query) \
| Q(traceback__icontains=query)
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
if not is_search:
message_list = message_list.order_by('-score', '-last_seen')
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = timezone.now()
has_realtime = page == 1
return render_to_response('sentry/index.html', {
'has_realtime': has_realtime,
'message_list': message_list,
'today': today,
'query': query,
'sort': sort,
'any_filter': any_filter,
'request': request,
'filters': filters,
})
def ajax_handler(request):
op = request.REQUEST.get('op')
if op == 'notification':
return render_to_response('sentry/partial/_notification.html', request.GET)
elif op == 'poll':
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
query = request.GET.get('content')
is_search = query
if is_search:
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) \
| Q(message__icontains=query) \
| Q(traceback__icontains=query)
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
if not is_search:
message_list = message_list.order_by('-score', '-last_seen')
for filter_ in filters:
if not filter_.is_set():
continue
message_list = filter_.get_query_set(message_list)
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'priority': p,
'request': request,
}).strip(),
'title': m.view or m.message_top(),
'message': m.error(),
'level': m.get_level_display(),
'logger': m.logger,
'count': m.times_seen,
'priority': p,
}) for m, p in with_priority(message_list[0:15])]
elif op == 'resolve':
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(request.META['HTTP_REFERER'])
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}).strip(),
'count': m.times_seen,
}) for m in [group]]
else:
return HttpResponseBadRequest()
response = HttpResponse(json.dumps(data))
response['Content-Type'] = 'application/json'
return response
def index(request):
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
try:
page = int(request.GET.get("p", 1))
except (TypeError, ValueError):
page = 1
query = request.GET.get("content")
is_search = query
if is_search:
if uuid_re.match(query):
# Forward to message if it exists
try:
message = Message.objects.get(message_id=query)
except Message.DoesNotExist:
pass
else:
return HttpResponseRedirect(message.get_absolute_url())
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) | Q(message__icontains=query) | Q(traceback__icontains=query)
)
sort = request.GET.get("sort")
if sort == "date":
message_list = message_list.order_by("-last_seen")
elif sort == "new":
message_list = message_list.order_by("-first_seen")
else:
sort = "priority"
if not is_search:
message_list = message_list.order_by("-score", "-last_seen")
any_filter = False
for filter_ in filters:
if not filter_.is_set():
continue
any_filter = True
message_list = filter_.get_query_set(message_list)
today = datetime.datetime.now()
has_realtime = page == 1
return render_to_response(
"sentry/index.html",
{
"has_realtime": has_realtime,
"message_list": message_list,
"today": today,
"query": query,
"sort": sort,
"any_filter": any_filter,
"request": request,
"filters": filters,
},
)
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 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 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 ajax_handler(request):
op = request.REQUEST.get("op")
if op == "notification":
return render_to_response("sentry/partial/_notification.html", request.GET)
elif op == "poll":
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
query = request.GET.get("content")
is_search = query
if is_search:
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(select={"score": GroupedMessage.get_score_clause()})
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) | Q(message__icontains=query) | Q(traceback__icontains=query)
)
sort = request.GET.get("sort")
if sort == "date":
message_list = message_list.order_by("-last_seen")
elif sort == "new":
message_list = message_list.order_by("-first_seen")
else:
sort = "priority"
if not is_search:
message_list = message_list.order_by("-score", "-last_seen")
for filter_ in filters:
if not filter_.is_set():
continue
message_list = filter_.get_query_set(message_list)
data = [
(
m.pk,
{
"html": render_to_string(
"sentry/partial/_group.html", {"group": m, "priority": p, "request": request}
).strip(),
"title": m.view or m.message_top(),
"message": m.error(),
"level": m.get_level_display(),
"logger": m.logger,
"count": m.times_seen,
"priority": p,
},
)
for m, p in with_priority(message_list[0:15])
]
elif op == "resolve":
gid = request.REQUEST.get("gid")
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(request.META["HTTP_REFERER"])
data = [
(
m.pk,
{
"html": render_to_string("sentry/partial/_group.html", {"group": m, "request": request}).strip(),
"count": m.times_seen,
},
)
for m in [group]
]
else:
return HttpResponseBadRequest()
response = HttpResponse(simplejson.dumps(data))
response["Content-Type"] = "application/json"
return response
def ajax_handler(request):
op = request.REQUEST.get('op')
if op == 'notification':
return render_to_response('sentry/partial/_notification.html',
request.GET,
context_instance=RequestContext(request))
elif op == 'poll':
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
query = request.GET.get('content')
is_search = query
if is_search:
message_list = get_search_query_set(query)
else:
message_list = GroupedMessage.objects.extra(
select={
'score': GroupedMessage.get_score_clause(),
}
)
if query:
# You really shouldnt be doing this
message_list = message_list.filter(
Q(view__icontains=query) \
| Q(message__icontains=query) \
| Q(traceback__icontains=query)
)
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
else:
sort = 'priority'
if not is_search:
message_list = message_list.order_by('-score', '-last_seen')
for filter_ in filters:
if not filter_.is_set():
continue
message_list = filter_.get_query_set(message_list)
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'priority': p,
'request': request,
}).strip(),
'title': m.view or m.message_top(),
'message': m.error(),
'level': m.get_level_display(),
'logger': m.logger,
'count': m.times_seen,
'priority': p,
}) for m, p in with_priority(message_list[0:15])]
elif op == 'resolve':
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(request.META['HTTP_REFERER'])
data = [
(m.pk, {
'html': render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}).strip(),
'count': m.times_seen,
}) for m in [group]]
else:
return HttpResponseBadRequest()
response = HttpResponse(simplejson.dumps(data))
response['Content-Type'] = 'application/json'
return response
def ajax_handler(request):
op = request.REQUEST.get('op')
if op == 'notification':
return render_to_response('sentry/partial/_notification.html',
request.GET)
elif op == 'poll':
filters = []
for filter_ in get_filters():
filters.append(filter_(request))
message_list = GroupedMessage.objects.all()
sort = request.GET.get('sort')
if sort == 'date':
message_list = message_list.order_by('-last_seen')
elif sort == 'new':
message_list = message_list.order_by('-first_seen')
elif sort == 'freq':
message_list = message_list.order_by('-times_seen')
else:
sort = 'priority'
message_list = message_list.order_by('-score', '-last_seen')
for filter_ in filters:
if not filter_.is_set():
continue
message_list = filter_.get_query_set(message_list)
data = [(m.pk, {
'html':
render_to_string('sentry/partial/_group.html', {
'group': m,
'priority': p,
'request': request,
}).strip(),
'title':
m.view or m.message_top(),
'message':
m.error(),
'level':
m.get_level_display(),
'logger':
m.logger,
'count':
m.times_seen,
'priority':
p,
}) for m, p in with_priority(message_list[0:15])]
elif op == 'resolve':
gid = request.REQUEST.get('gid')
if not gid:
return HttpResponseForbidden()
try:
group = GroupedMessage.objects.get(pk=gid)
except GroupedMessage.DoesNotExist:
return HttpResponseForbidden()
GroupedMessage.objects.filter(pk=group.pk).update(status=1)
group.status = 1
if not request.is_ajax():
return HttpResponseRedirect(
request.META.get('HTTP_REFERER') or reverse('sentry'))
data = [(m.pk, {
'html':
render_to_string('sentry/partial/_group.html', {
'group': m,
'request': request,
}).strip(),
'count':
m.times_seen,
}) for m in [group]]
else:
return HttpResponseBadRequest()
response = HttpResponse(simplejson.dumps(data))
response['Content-Type'] = 'application/json'
return response
