def test_get_versions(self):
import sentry
from sentry.helpers import get_versions
versions = get_versions(['sentry'])
self.assertEquals(versions.get('sentry'), sentry.VERSION)
versions = get_versions(['sentry.client'])
self.assertEquals(versions.get('sentry'), sentry.VERSION)
def test_get_versions(self):
import sentry
from sentry.helpers import get_versions
versions = get_versions(['sentry'])
self.assertEquals(versions.get('sentry'), sentry.VERSION)
versions = get_versions(['sentry.client'])
self.assertEquals(versions.get('sentry'), sentry.VERSION)
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 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 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
