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