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