def initialize():
    global _initialized

    with _setup_lock:
        if _initialized:
            return

        _initialized = True

        try:
            register_serializers()
            install_middleware(
                'raven.contrib.django.middleware.SentryMiddleware',
                (
                    'raven.contrib.django.middleware.SentryMiddleware',
                    'raven.contrib.django.middleware.SentryLogMiddleware'))
            install_middleware(
                'raven.contrib.django.middleware.DjangoRestFrameworkCompatMiddleware')

            handler = CustomSentryDjangoHandler()
            handler.install()

            # instantiate client so hooks get registered
            get_client()  # NOQA
        except Exception:
            _initialized = False

    def test_does_exclude_filtered_types(self, exc_info, mock_capture):
        exc_info.return_value = self.exc_info
        try:
            get_client().ignore_exceptions = set(['ValueError'])

            sentry_exception_handler(request=self.request)
        finally:
            get_client().ignore_exceptions.clear()

        assert not mock_capture.called

    def test_invalid_client(self):
        extra_settings = {"SENTRY_CLIENT": "raven.contrib.django.DjangoClient"}  # default
        # Should return fallback client (TempStoreClient)
        client = get_client("nonexistent.and.invalid")

        # client should be valid, and the same as with the next call.
        assert client is get_client()

        with Settings(**extra_settings):
            assert isinstance(get_client(), DjangoClient)

    def test_ignore_exceptions_with_module_match(self, exc_info, mock_capture):
        exc_info.return_value = self.exc_info

        if six.PY3:
            get_client().ignore_exceptions = set(['builtins.ValueError'])
        else:
            get_client().ignore_exceptions = set(['exceptions.ValueError'])

        sentry_exception_handler(request=self.request)

        assert not mock_capture.called

    def test_invalid_client(self):
        extra_settings = {
            'SENTRY_CLIENT': 'raven.contrib.django.DjangoClient',  # default
        }
        # Should return fallback client (MockClient)
        client = get_client('nonexistent.and.invalid')

        # client should be valid, and the same as with the next call.
        assert client is get_client()

        with Settings(**extra_settings):
            assert isinstance(get_client(), DjangoClient)

    def test_ignore_exceptions_with_expression_match(self, exc_info, mock_capture):
        exc_info.return_value = self.exc_info

        try:
            if six.PY3:
                get_client().ignore_exceptions = set(['builtins.*'])
            else:
                get_client().ignore_exceptions = set(['exceptions.*'])
            sentry_exception_handler(request=self.request)
        finally:
            get_client().ignore_exceptions.clear()

        assert not mock_capture.called

    def test_basic(self):
        with Settings(HEKA_CONF=self.HEKA_CONF,
                      HEKA=self.HEKA,
                      SENTRY_CLIENT=self.SENTRY_CLIENT,
                      SENTRY_DSN=DSN):

            self.raven = get_client()

            self.raven.capture('Message', message='foo')

            msgs = []
            for mdata in settings.HEKA.stream.msgs:
                h, m = decode_message(mdata)
                msgs.append(m)

            self.assertEquals(len(msgs), 1)
            event = self.raven.decode(msgs[0].payload)

            self.assertTrue('sentry.interfaces.Message' in event)
            message = event['sentry.interfaces.Message']
            self.assertEquals(message['message'], 'foo')
            self.assertEquals(event['level'], logging.ERROR)
            self.assertEquals(event['message'], 'foo')

            # The project_id must be extracted from the SENTRY_DSN
            # option
            self.assertEquals(event['project'],
                    str(TESTING_PROJECT_ID))

            # This is different than the regular Django test as we are
            # *decoding* a serialized message - so instead of checking
            # for datetime, we expect a string
            self.assertTrue(isinstance(event['timestamp'], basestring))

def get_sentry_handler():
    # This should effectively make Tastypie do the same thing as
    # the error trapping in
    # raven.contrib.django.models:sentry_exception_handler
    from raven.contrib.django.models import get_client
    handler = SentryHandler(get_client())
    return handler

    def test_signal_integration(self):
        with Settings(METLOG_CONF=self.METLOG_CONF,
                      METLOG=self.METLOG,
                      SENTRY_CLIENT=self.SENTRY_CLIENT,
                      SENTRY_DSN=DSN):

            self.raven = get_client()

            try:
                int('hello')
            except:
                got_request_exception.send(sender=self.__class__, request=None)
            else:
                self.fail('Expected an exception.')

            msgs = settings.METLOG.sender.msgs

            self.assertEquals(len(msgs), 1)

            event = self.raven.decode(json.loads(msgs[0])['payload'])
            self.assertTrue('sentry.interfaces.Exception' in event)
            exc = event['sentry.interfaces.Exception']
            self.assertEquals(exc['type'], 'ValueError')
            self.assertEquals(exc['value'], u"invalid literal for int() with base 10: 'hello'")
            self.assertEquals(event['level'], logging.ERROR)
            self.assertEquals(event['message'], u"ValueError: invalid literal for int() with base 10: 'hello'")
            self.assertEquals(event['culprit'], 'tests.contrib.django.tests.test_signal_integration')

            # The project_id must be extracted from the SENTRY_DSN
            # option
            self.assertEquals(event['project'],
                    str(TESTING_PROJECT_ID))

    def test_cookies(self):
        request = APIRequestFactory().post('/')
        request.COOKIES['username'] = 'jimmy'

        raven = get_client()
        result = raven.get_data_from_request(request)

        self.assertFalse('cookies' in result['request'])
        self.assertFalse('Cookie' in result['request']['headers'])

 def process_response(self, request, response):
     if response.status_code != 404 or _is_ignorable_404(request.get_full_path()):
         return response
     client = get_client()
     result = client.create_from_text('Http 404', request=request, level=logging.INFO, logger='http404')
     request.sentry = {
         'id': client.get_ident(result),
     }
     return response

def main():
    settings_from_file(os.path.expanduser(os.path.join('~', '.sentry', 'sentry.conf.py')))

    from raven.contrib.django.models import get_client

    client = get_client()
    functions = funcs()

    while True:
        random.choice(functions)(client)

        time.sleep(1)

    def test_get_client(self):
        self.assertEquals(get_client(), get_client())
        self.assertEquals(get_client('raven.base.Client').__class__, Client)
        self.assertEquals(get_client(), self.raven)

        self.assertEquals(get_client('%s.%s' % (self.raven.__class__.__module__, self.raven.__class__.__name__)), self.raven)
        self.assertEquals(get_client(), self.raven)

def sync_changed_files(sync_key, last_commit_hash, sync_url, project_dir):
    try:
        _sync_changed_files(sync_key, last_commit_hash, sync_url, project_dir)
    except Exception:
        import traceback
        traceback.print_exc()
        exc_info = sys.exc_info()
        try:
            raven_client = get_client()
            raven_client.captureException(exc_info=exc_info)
        except:
            import traceback
            traceback.print_exc()
            pass

    def emit(self, record):
        from raven.contrib.django.middleware import SentryLogMiddleware
        from raven.contrib.django.models import get_client

        # 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.startswith('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 process_response(self, request, response):
     if response.status_code != 404 or _is_ignorable_404(request.get_full_path()):
         return response
     client = get_client()
     data = client.get_data_from_request(request)
     data.update({
         'level': logging.INFO,
         'logger': 'http404',
     })
     result = client.capture('Message', message='Page Not Found: %s' % request.build_absolute_uri(), data=data)
     request.sentry = {
         'project_id': data.get('project', client.project),
         'id': client.get_ident(result),
     }
     return response

    def _wrapper(*args, **kwargs):
        try:
            func(*args, **kwargs)
        except Exception:
            # not sure about this...
            import traceback

            traceback.print_exc()
            exc_info = sys.exc_info()

            try:
                raven_client = get_client()
                raven_client.captureException(exc_info=exc_info)
            except:
                import traceback

                traceback.print_exc()

    def handle(self, **options):
        from raven.contrib.django.models import get_client

        client = get_client()
        functions = funcs()

        s = time.time()
        r = 0
        try:
            while True:
                random.choice(functions)(client)
                r += 1
        except KeyboardInterrupt:
            pass
        finally:
            total_time = time.time() - s
            print '%d requests serviced in %.3fs' % (r, total_time)
            avg = total_time / r
            print 'avg of %.3fs/req, %d req/s' % (avg, 1 / avg)

def main():
    settings_from_file(os.path.expanduser(os.path.join('~', '.sentry', 'sentry.conf.py')))

    from raven.contrib.django.models import get_client

    client = get_client()
    functions = funcs()

    s = time.time()
    r = 0
    try:
        while True:
            random.choice(functions)(client)
            r += 1
            eventlet.sleep(0.1)
    except KeyboardInterrupt:
        pass
    finally:
        total_time = time.time() - s
        print '%d requests serviced in %.3fs' % (r, total_time)
        avg = total_time / r
        print 'avg of %.3fs/req, %d req/s' % (avg, 1 / avg)

    def handle(self, **options):
        from raven.contrib.django.models import get_client

        client = get_client()
        functions = funcs()

        s = time.time()
        r = 0
        pool = eventlet.GreenPool(16)
        try:
            while True:
                pool.spawn_n(random.choice(functions), (client))
                r += 1
                # eventlet.sleep(0.3)
        except KeyboardInterrupt:
            pass
        finally:
            pool.waitall()
            total_time = time.time() - s
            print '%d requests serviced in %.3fs' % (r, total_time)
            avg = total_time / r
            print 'avg of %.3fs/req, %d req/s' % (avg, 1 / avg)