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 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_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_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_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_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_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_ignore_exceptions_with_module_match(self, exc_info, mock_capture):
exc_info.return_value = self.exc_info
try:
if six.PY3:
get_client().ignore_exceptions = set(['builtins.ValueError'])
else:
get_client().ignore_exceptions = set(['exceptions.ValueError'])
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 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 initialize():
global _initialized
with _setup_lock:
if _initialized:
return
register_serializers()
install_middleware()
handler = CustomSentryDjangoHandler()
handler.install()
# instantiate client so hooks get registered
get_client() # NOQA
_initialized = True
def test_transport_specification(self):
extra_settings = {
'SENTRY_TRANSPORT': 'raven.transport.HTTPTransport',
'SENTRY_DSN': 'http://*****:*****@example.com/1',
}
with Settings(**extra_settings):
client = get_client(reset=True)
assert type(client.remote.get_transport()) is HTTPTransport
def test_transport_specification(self):
extra_settings = {
'SENTRY_TRANSPORT': 'raven.transport.HTTPTransport',
'SENTRY_DSN': 'http://*****:*****@example.com/1',
}
with Settings(**extra_settings):
client = get_client(reset=True)
assert type(client.remote.get_transport()) is HTTPTransport
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 test_cookies(self):
request = APIRequestFactory().post('/')
request.COOKIES['username'] = '******'
raven = get_client()
result = raven.get_data_from_request(request)
self.assertFalse('cookies' in result['request'])
self.assertFalse('Cookie' in result['request']['headers'])
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):
assert get_client() == get_client()
assert get_client('raven.base.Client').__class__ == Client
assert get_client() == self.raven
assert get_client('%s.%s' % (type(self.raven).__module__, type(self.raven).__name__)) == self.raven
assert get_client() == self.raven
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 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 test_get_client(self):
assert get_client() == get_client()
assert get_client('raven.base.Client').__class__ == Client
assert get_client() == self.raven
assert get_client('%s.%s' % (type(self.raven).__module__, type(self.raven).__name__)) == self.raven
assert get_client() == self.raven
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 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 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(record, '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 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 test_signal_integration(self):
with Settings(HEKA_CONF=self.HEKA_CONF,
HEKA=self.HEKA,
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 = []
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.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 in test_signal_integration')
# The project_id must be extracted from the SENTRY_DSN
# option
self.assertEquals(event['project'], str(TESTING_PROJECT_ID))
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)
def setUp(self):
self.raven = get_client()
def test_proxy_responds_as_client(self):
self.assertEquals(get_client(), client)
def _get_client(self):
from raven.contrib.django.models import get_client
return get_client()
def setUp(self):
super(SentryExceptionHandlerTest, self).setUp()
self.client = get_client()
self.handler = SentryDjangoHandler(self.client)
def setUp(self):
super(SentryExceptionHandlerTest, self).setUp()
self.client = get_client()
self.handler = SentryDjangoHandler(self.client)
""" raven.contrib.django.celery.tasks ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :copyright: (c) 2010 by the Sentry Team, see AUTHORS for more details. :license: BSD, see LICENSE for more details. """ # TODO: need to educate myself on how this works from raven.contrib.django.models import get_client # We just need to pull in the client to ensure the task is registered client = get_client()
def send_raw(*args, **kwargs):
super(DjangoClient, get_client()).send_encoded(*args, **kwargs)
def send_raw_integrated(kwargs):
super(DjangoClient, get_client()).send_integrated(kwargs)
def send_raw(*args, **kwargs):
from raven.contrib.django.models import get_client
super(DjangoClient, get_client()).send_encoded(*args, **kwargs)
#!/usr/bin/env python
import os
import sys
import traceback
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "openahjo.settings")
from django.core.management import execute_from_command_line
try:
execute_from_command_line(sys.argv)
except Exception as e:
if sys.stdout.isatty():
traceback.print_exc()
else:
from django.conf import settings
if settings.DEBUG or not hasattr(settings, 'RAVEN_CONFIG'):
raise
from raven.contrib.django.models import get_client
exc_info = sys.exc_info()
if getattr(exc_info[0], 'skip_sentry', False):
raise
get_client().captureException(exc_info)
raise
def test_wrong_params(self):
query = 'SELECT COUNT(*) FROM mytestmodel WHERE id = %s'
args = ['foobar', 42]
record_sql(None, None, None, None, query, args)
crumbs = get_client().context.breadcrumbs.get_buffer()
self.assertEqual(crumbs[-1]['message'], query)
def test_proxy_responds_as_client(self):
assert get_client() == client
def test_proxy_responds_as_client(self):
assert get_client() == client
def setUp(self):
self.raven = get_client()
self.handler = SentryDjangoHandler(self.raven)
self.handler.install()
self.addCleanup(self.handler.uninstall)
def setUp(self):
self.logger = logging.getLogger(__name__)
self.raven = get_client()
def test_proxy_responds_as_client(self):
self.assertEquals(get_client(), client)
def setUp(self):
self.raven = get_client()
def setUp(self):
self.logger = logging.getLogger(__name__)
self.raven = get_client()
def client(self):
if self._client is None:
self._client = get_client(
getattr(settings, 'SENTRY_GEARMAN_CLIENT',
'raven.contrib.django.client.DjangoClient'))
return self._client
def send_raw_integrated(kwargs):
from raven.contrib.django.models import get_client
super(DjangoClient, get_client()).send_integrated(kwargs)
def setUp(self):
self.raven = get_client()
self.handler = SentryDjangoHandler(self.raven)
self.handler.install()
self.addCleanup(self.handler.uninstall)