def testAlternateDatabase(self):
conf.DATABASE_USING = 'default'
try:
Message.objects.get(id=999999979)
except Message.DoesNotExist, exc:
get_client().create_from_exception()
def testAlternateDatabase(self):
settings.DATABASE_USING = 'default'
try:
Message.objects.get(id=999999979)
except Message.DoesNotExist, exc:
get_client().create_from_exception(exc)
def testExclusionViewPath(self):
try: Message.objects.get(pk=1341324)
except: get_client().create_from_exception()
last = Message.objects.get()
self.assertEquals(last.view, 'sentry.tests.tests.testExclusionViewPath')
def emit(self, record):
from sentry.client.models import get_client
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
get_client().create_from_record(record)
def emit(self, record):
from sentry.client.models import get_client
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
get_client().create_from_record(record)
def test_best_guess_view(self):
settings.EXCLUDE_PATHS = ['tests.tests']
try: Message.objects.get(pk=1341324)
except: get_client().create_from_exception()
last = Message.objects.get()
self.assertEquals(last.view, 'tests.tests.test_best_guess_view')
settings.EXCLUDE_PATHS = []
def testThrashing(self):
conf.THRASHING_LIMIT = 10
conf.THRASHING_TIMEOUT = 60
Message.objects.all().delete()
GroupedMessage.objects.all().delete()
for i in range(0, 50):
get_client().create_from_text('hi')
self.assertEquals(Message.objects.count(), conf.THRASHING_LIMIT)
def log_with_stacktrace(message, level=logging.INFO, logger='hiicart.audit'):
client = get_client()
if client is None:
logger = logging.get_logger()
logger.warn("Could not save stack trace for message: %s" % message)
return
kwargs = dict(level=level, logger=logger)
stack = inspect.stack()[1:]
tb = FakeTraceback(stack)
exc_info = (AuditingStacktrace, AuditingStacktrace(message), tb)
get_client().create_from_exception(exc_info, **kwargs)
def testBestGuessView(self):
conf.EXCLUDE_PATHS = ['sentry.tests.tests']
try: Message.objects.get(pk=1341324)
except: get_client().create_from_exception()
last = Message.objects.get()
self.assertEquals(last.view, 'sentry.tests.tests.testBestGuessView')
conf.EXCLUDE_PATHS = []
def testThrashing(self):
settings.THRASHING_LIMIT = 10
settings.THRASHING_TIMEOUT = 60
Message.objects.all().delete()
GroupedMessage.objects.all().delete()
for i in range(0, 50):
get_client().create_from_text('hi')
self.assertEquals(Message.objects.count(), settings.THRASHING_LIMIT)
def log_with_stacktrace(message, level=logging.INFO, logger='hiicart.audit'):
client = get_client()
if client is None:
logger = logging.get_logger()
logger.warn("Could not save stack trace for message: %s" % message)
return
kwargs = dict(level=level, logger=logger)
stack = inspect.stack()[1:]
tb = FakeTraceback(stack)
exc_info = (AuditingStacktrace, AuditingStacktrace(message), tb)
get_client().create_from_exception(exc_info, **kwargs)
def testNoThrashing(self):
prev = settings.THRASHING_LIMIT
settings.THRASHING_LIMIT = 0
Message.objects.all().delete()
GroupedMessage.objects.all().delete()
for i in range(0, 50):
get_client().create_from_text('hi')
self.assertEquals(Message.objects.count(), 50)
settings.THRASHING_LIMIT = prev
def emit(self, record):
from sentry.client.models import get_client
from sentry.client.middleware import SentryLogMiddleware
# Fetch the request from a threadlocal variable, if available
request = getattr(SentryLogMiddleware.thread, "request", None)
# Avoid typical config issues by overriding loggers behavior
if record.name == "sentry.errors":
print >>sys.stderr, "Recursive log message sent to SentryHandler"
print >>sys.stderr, record.message
return
get_client().create_from_record(record, request=request)
def emit(self, record):
from sentry.client.models import get_client
from sentry.client.middleware import SentryLogMiddleware
# Fetch the request from a threadlocal variable, if available
request = getattr(SentryLogMiddleware.thread, 'request', None)
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
get_client().create_from_record(record, request=request)
def testAPI(self):
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
message_id = get_client().create_from_exception()
error = Message.objects.get(message_id=message_id)
self.assertTrue(error.data.get('__sentry__', {}).get('exc'))
def testAPI(self):
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
message_id = get_client().create_from_exception()
error = Message.objects.get(message_id=message_id)
self.assertTrue(error.data.get('__sentry__', {}).get('exc'))
def testLongURLs(self):
# Fix: #6 solves URLs > 200 characters
message_id = get_client().create_from_text('hello world', url='a'*210)
error = Message.objects.get(message_id=message_id)
self.assertEquals(error.url, 'a'*200)
self.assertEquals(error.data['url'], 'a'*210)
def process_response(self, request, response):
if response.status_code == 404 and request.META.get('HTTP_REFERER', '') and not sentry_settings.DEBUG:
request.META['TURANUSER'] = request.user
message_id = get_client().create_from_text('Http 404 %s' %request.path, request=request, level=logging.INFO, logger='http404')
request.sentry = {
'id': message_id,
}
return response
def process_response(self, request, response):
if response.status_code != 404:
return response
message_id = get_client().create_from_text('Http 404', request=request, level=logging.INFO, logger='http404')
request.sentry = {
'id': message_id,
}
return response
def test_thrashing(self):
settings.THRASHING_LIMIT = 10
settings.THRASHING_TIMEOUT = 60
Message.objects.all().delete()
GroupedMessage.objects.all().delete()
message_id = None
for i in range(0, 10):
this_message_id = get_client().create_from_text('hi')
self.assertTrue(this_message_id is not None)
self.assertNotEquals(this_message_id, message_id)
message_id = this_message_id
for i in range(0, 40):
this_message_id = get_client().create_from_text('hi')
self.assertEquals(this_message_id, message_id)
self.assertEquals(Message.objects.count(), settings.THRASHING_LIMIT)
def testThrashing(self):
conf.THRASHING_LIMIT = 10
conf.THRASHING_TIMEOUT = 60
Message.objects.all().delete()
GroupedMessage.objects.all().delete()
message_id = None
for i in range(0, 10):
this_message_id = get_client().create_from_text('hi')
self.assertTrue(this_message_id is not None)
self.assertNotEquals(this_message_id, message_id)
message_id = this_message_id
for i in range(0, 40):
this_message_id = get_client().create_from_text('hi')
self.assertEquals(this_message_id, message_id)
self.assertEquals(Message.objects.count(), conf.THRASHING_LIMIT)
def main_thread_terminated():
client = get_client()
if isinstance(client, AsyncSentryClient):
size = client.queue.qsize()
if size:
print "Sentry attempts to send %s error messages" % size
print "Waiting up to %s seconds" % SENTRY_WAIT_SECONDS
if os.name == 'nt':
print "Press Ctrl-Break to quit"
else:
print "Press Ctrl-C to quit"
client.stop(timeout = SENTRY_WAIT_SECONDS)
def main_thread_terminated():
client = get_client()
if isinstance(client, AsyncSentryClient):
size = client.queue.qsize()
if size:
print "Sentry attempts to send %s error messages" % size
print "Waiting up to %s seconds" % SENTRY_WAIT_SECONDS
if os.name == 'nt':
print "Press Ctrl-Break to quit"
else:
print "Press Ctrl-C to quit"
client.stop(timeout = SENTRY_WAIT_SECONDS)
def process_exception(self, request, exception):
if type(exception) == Http500:
message_id = get_client().create_from_exception(
sys.exc_info(),
request=request,
level=logging.ERROR,
logger='http500')
request.sentry = {
'id': message_id,
}
return handle_500(request, str(exception))
elif type(exception) == Http404:
message_id = get_client().create_from_exception(sys.exc_info(),
request=request,
level=logging.INFO,
logger='http404')
request.sentry = {
'id': message_id,
}
return handle_404(request, str(exception))
elif type(exception) == Http403:
message_id = get_client().create_from_exception(sys.exc_info(),
request=request,
level=logging.INFO,
logger='http403')
request.sentry = {
'id': message_id,
}
return handle_403(request, str(exception))
elif type(exception) == Http400:
message_id = get_client().create_from_exception(
sys.exc_info(),
request=request,
level=logging.WARNING,
logger='http400')
request.sentry = {
'id': message_id,
}
return handle_400(request, str(exception))
return None
def emit(self, record):
from sentry.client.models import get_client
from sentry.client.middleware import SentryLogMiddleware
# Fetch the request from a threadlocal variable, if available
request = getattr(SentryLogMiddleware.thread, 'request', None)
self.format(record)
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
self.format(record)
try:
get_client().create_from_record(record, request=request)
except Exception:
print >> sys.stderr, "Top level Sentry exception caught - failed creating log record"
print >> sys.stderr, record.msg
return
def emit(self, record):
from sentry.client.models import get_client
# Avoid typical config issues by overriding loggers behavior
if record.name == "sentry.errors":
print >>sys.stderr, "Recursive log message sent to SentryHandler"
print >>sys.stderr, record.message
return
kwargs = dict(message=record.message, level=record.level, logger=record.channel, data=record.extra)
client = get_client()
if record.exc_info:
return client.create_from_exception(record.exc_info, **kwargs)
return client.create_from_text(**kwargs)
def emit(self, record):
from sentry.client.models import get_client
from sentry.client.middleware import SentryLogMiddleware
# Fetch the request from a threadlocal variable, if available
request = getattr(SentryLogMiddleware.thread, 'request', None)
self.format(record)
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
self.format(record)
try:
get_client().create_from_record(record, request=request)
except Exception:
print >> sys.stderr, "Top level Sentry exception caught - failed creating log record"
print >> sys.stderr, record.msg
print >> sys.stderr, traceback.format_exc()
return
def testBrokenCache(self):
from django.core.cache import cache
add_func = cache.add
cache.add = lambda: False
client = get_client()
settings.THRASHING_LIMIT = 10
settings.THRASHING_TIMEOUT = 60
result = client.check_throttle('foobar')
self.assertEquals(result, (False, None))
cache.add = add_func
def test_broken_cache(self):
from django.core.cache import cache
add_func = cache.add
cache.add = lambda: False
client = get_client()
settings.THRASHING_LIMIT = 10
settings.THRASHING_TIMEOUT = 60
result = client.check_throttle('foobar')
self.assertEquals(result, (False, None))
cache.add = add_func
def testCreateFromRecordNoneExcInfo(self):
# sys.exc_info can return (None, None, None) if no exception is being
# handled anywhere on the stack. See:
# http://docs.python.org/library/sys.html#sys.exc_info
client = get_client()
record = logging.LogRecord(
'foo',
logging.INFO,
pathname=None,
lineno=None,
msg='test',
args=(),
exc_info=(None, None, None),
)
message = client.create_from_record(record)
self.assertEquals('test', message.message)
def test_get_client(self):
from sentry.client.log import LoggingSentryClient
self.assertEquals(get_client().__class__, SentryClient)
self.assertEquals(get_client(), get_client())
conf.CLIENT = 'sentry.client.log.LoggingSentryClient'
self.assertEquals(get_client().__class__, LoggingSentryClient)
self.assertEquals(get_client(), get_client())
conf.CLIENT = 'sentry.client.base.SentryClient'
def process_response(self, request, response):
if not hasattr(response, "status_code"):
return response
if response.status_code == 404 \
and request.META.get('HTTP_REFERER', '') \
and not request.path.endswith('undefined') \
and not sentry_settings.DEBUG:
request.META['TURANUSER'] = request.user
message_id = get_client().create_from_text('Http 404 %s' %
request.path,
request=request,
level=logging.INFO,
logger='http404')
request.sentry = {
'id': message_id,
}
return response
def test_logging_client(self):
settings.CLIENT = 'sentry.client.log.LoggingSentryClient'
client = get_client()
_foo = {'': None}
class handler(logging.Handler):
def emit(self, record):
_foo[''] = record
logger = client.logger
logger.addHandler(handler())
self.assertRaises(Exception, self.client.get, reverse('sentry-raise-exc'))
self.assertEquals(_foo[''].getMessage(), 'view exception')
self.assertEquals(_foo[''].levelno, client.default_level)
self.assertEquals(_foo[''].class_name, 'Exception')
def emit(self, record):
from sentry.client.models import get_client
# Avoid typical config issues by overriding loggers behavior
if record.name == 'sentry.errors':
print >> sys.stderr, "Recursive log message sent to SentryHandler"
print >> sys.stderr, record.message
return
kwargs = dict(
message=record.message,
level=record.level,
logger=record.channel,
data=record.extra,
)
client = get_client()
if record.exc_info:
return client.create_from_exception(record.exc_info, **kwargs)
return client.create_from_text(**kwargs)
def test_logging_client(self):
conf.CLIENT = 'sentry.client.log.LoggingSentryClient'
client = get_client()
_foo = {'': None}
class handler(logging.Handler):
def emit(self, record):
_foo[''] = record
logger = client.logger
logger.addHandler(handler())
self.assertRaises(Exception, self.client.get, reverse('sentry-raise-exc'))
self.assertEquals(_foo[''].getMessage(), 'view exception')
self.assertEquals(_foo[''].levelno, client.default_level)
self.assertEquals(_foo[''].class_name, 'Exception')
def testCorrectUnicode(self):
self.setUpHandler()
cnt = Message.objects.count()
value = 'רונית מגן'.decode('utf-8')
error = get_client().create_from_text(value)
self.assertEquals(Message.objects.count(), cnt + 1)
self.assertEquals(error.message, value)
logging.info(value)
self.assertEquals(Message.objects.count(), cnt + 2)
x = TestModel.objects.create(data={'value': value})
logging.warn(x)
self.assertEquals(Message.objects.count(), cnt + 3)
try:
raise SyntaxMessage(value)
except Exception, exc:
logging.exception(exc)
logging.info('test', exc_info=sys.exc_info())
def testCorrectUnicode(self):
self.setUpHandler()
cnt = Message.objects.count()
value = 'רונית מגן'.decode('utf-8')
error = get_client().create_from_text(value)
self.assertEquals(Message.objects.count(), cnt+1)
self.assertEquals(error.message, value)
logging.info(value)
self.assertEquals(Message.objects.count(), cnt+2)
x = TestModel.objects.create(data={'value': value})
logging.warn(x)
self.assertEquals(Message.objects.count(), cnt+3)
try:
raise SyntaxMessage(value)
except Exception, exc:
logging.exception(exc)
logging.info('test', exc_info=sys.exc_info())
def test_celery_client(self):
from sentry.client.celery import CelerySentryClient
self.assertEquals(get_client().__class__, SentryClient)
self.assertEquals(get_client(), get_client())
conf.CLIENT = 'sentry.client.celery.CelerySentryClient'
self.assertEquals(get_client().__class__, CelerySentryClient)
self.assertEquals(get_client(), get_client())
self.assertRaises(Exception, self.client.get, reverse('sentry-raise-exc'))
message = GroupedMessage.objects.get()
self.assertEqual(message.class_name, 'Exception')
self.assertEqual(message.message, 'view exception')
conf.CLIENT = 'sentry.client.base.SentryClient'
def test_incorrect_unicode(self):
self.setUpHandler()
cnt = Message.objects.count()
value = 'רונית מגן'
message_id = get_client().create_from_text(value)
error = Message.objects.get(message_id=message_id)
self.assertEquals(Message.objects.count(), cnt+1)
self.assertEquals(error.message, u'רונית מגן')
logging.info(value)
self.assertEquals(Message.objects.count(), cnt+2)
x = TestModel.objects.create(data={'value': value})
logging.warn(x)
self.assertEquals(Message.objects.count(), cnt+3)
try:
raise SyntaxMessage(value)
except Exception, exc:
logging.exception(exc)
logging.info('test', exc_info=True)
def emit(self, record):
from sentry.client.models import get_client
get_client().create_from_record(record)
def testLongURLs(self):
# Fix: #6 solves URLs > 200 characters
error = get_client().create_from_text('hello world', url='a' * 210)
self.assertEquals(error.url, 'a' * 200)
self.assertEquals(error.data['url'], 'a' * 210)
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
sys.exit(1)
if __name__ == "__main__":
try:
execute_manager(settings)
except Exception, e:
# Custom handling of exceptions to make sure
# that Sentry handles them.
import sys, traceback
if sys.stdout.isatty():
traceback.print_exc()
else:
if settings.DEBUG or not 'sentry.client' in settings.INSTALLED_APPS:
raise
from sentry.client.models import get_client
exc_info = sys.exc_info()
if getattr(exc_info[0], 'skip_sentry', False):
raise
get_client().create_from_exception(exc_info)
# Email admins
import logging
logger = logging.getLogger('management_commands')
logger.exception(e)
# self.assertEquals(last.message, 'foo')
def testAPI(self):
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
message_id = get_client().create_from_exception()
error = Message.objects.get(message_id=message_id)
self.assertTrue(error.data.get('__sentry__', {}).get('exc'))
else:
self.fail('Unable to create `Message` entry.')
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
message_id = get_client().create_from_exception()
error = Message.objects.get(message_id=message_id)
self.assertTrue(error.data.get('__sentry__', {}).get('exc'))
else:
self.fail('Unable to create `Message` entry.')
self.assertEquals(Message.objects.count(), 2)
self.assertEquals(GroupedMessage.objects.count(), 2)
last = Message.objects.all().order_by('-id')[0:1].get()
self.assertEquals(last.logger, 'root')
self.assertEquals(last.class_name, 'DoesNotExist')
self.assertEquals(last.level, logging.ERROR)
self.assertEquals(last.message, smart_unicode(exc))
get_client().create_from_text('This is an error', level=logging.DEBUG)
self.assertEquals(last.class_name, 'DoesNotExist')
self.assertEquals(last.level, logging.ERROR)
self.assertEquals(last.message, smart_unicode(exc))
def testAPI(self):
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
get_client().create_from_exception(exc)
else:
self.fail('Unable to create `Message` entry.')
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
error = get_client().create_from_exception()
self.assertTrue(error.data.get('__sentry__', {}).get('exc'))
else:
self.fail('Unable to create `Message` entry.')
self.assertEquals(Message.objects.count(), 2)
self.assertEquals(GroupedMessage.objects.count(), 2)
last = Message.objects.all().order_by('-id')[0:1].get()
self.assertEquals(last.logger, 'root')
self.assertEquals(last.class_name, 'DoesNotExist')
self.assertEquals(last.level, logging.ERROR)
self.assertEquals(last.message, smart_unicode(exc))
get_client().create_from_text('This is an error', level=logging.DEBUG)
def testAPI(self):
try:
Message.objects.get(id=999999989)
except Message.DoesNotExist, exc:
get_client().create_from_exception(exc)
def testLongURLs(self):
# Fix: #6 solves URLs > 200 characters
error = get_client().create_from_text('hello world', url='a'*210)
self.assertEquals(error.url, 'a'*200)
self.assertEquals(error.data['url'], 'a'*210)
