????
Your IP : 52.14.204.52
"""
raven.contrib.sanic
~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2018 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
import logging
import blinker
from raven.conf import setup_logging
from raven.base import Client
from raven.handlers.logging import SentryHandler
from raven.utils.compat import urlparse
from raven.utils.encoding import to_unicode
from raven.utils.conf import convert_options
raven_signals = blinker.Namespace()
logging_configured = raven_signals.signal('logging_configured')
def make_client(client_cls, app, dsn=None):
return client_cls(
**convert_options(
app.config,
defaults={
'dsn': dsn,
'include_paths': (
set(app.config.get('SENTRY_INCLUDE_PATHS', []))
| set([app.name])
),
'extra': {
'app': app,
},
},
)
)
class Sentry(object):
"""
Sanic application for Sentry.
Look up configuration from ``os.environ['SENTRY_DSN']``::
>>> sentry = Sentry(app)
Pass an arbitrary DSN::
>>> sentry = Sentry(app, dsn='http://public:secret@example.com/1')
Pass an explicit client::
>>> sentry = Sentry(app, client=client)
Automatically configure logging::
>>> sentry = Sentry(app, logging=True, level=logging.ERROR)
Capture an exception::
>>> try:
>>> 1 / 0
>>> except ZeroDivisionError:
>>> sentry.captureException()
Capture a message::
>>> sentry.captureMessage('hello, world!')
"""
def __init__(self, app, client=None, client_cls=Client, dsn=None,
logging=False, logging_exclusions=None, level=logging.NOTSET):
if client and not isinstance(client, Client):
raise TypeError('client should be an instance of Client')
self.client = client
self.client_cls = client_cls
self.dsn = dsn
self.logging = logging
self.logging_exclusions = logging_exclusions
self.level = level
self.init_app(app)
def handle_exception(self, request, exception):
if not self.client:
return
try:
self.client.http_context(self.get_http_info(request))
except Exception as e:
self.client.logger.exception(to_unicode(e))
# Since Sanic is restricted to Python 3, let's be explicit with what
# we pass for exception info, rather than relying on sys.exc_info().
exception_info = (type(exception), exception, exception.__traceback__)
self.captureException(exc_info=exception_info)
def get_form_data(self, request):
return request.form
def get_http_info(self, request):
"""
Determine how to retrieve actual data by using request.mimetype.
"""
if self.is_json_type(request):
retriever = self.get_json_data
else:
retriever = self.get_form_data
return self.get_http_info_with_retriever(request, retriever)
def get_json_data(self, request):
return request.json
def get_http_info_with_retriever(self, request, retriever):
"""
Exact method for getting http_info but with form data work around.
"""
urlparts = urlparse.urlsplit(request.url)
try:
data = retriever(request)
except Exception:
data = {}
return {
'url': '{0}://{1}{2}'.format(
urlparts.scheme, urlparts.netloc, urlparts.path),
'query_string': urlparts.query,
'method': request.method,
'data': data,
'cookies': request.cookies,
'headers': request.headers,
'env': {
'REMOTE_ADDR': request.remote_addr,
}
}
def is_json_type(self, request):
content_type = request.headers.get('content-type')
return content_type == 'application/json'
def init_app(self, app, dsn=None, logging=None, level=None,
logging_exclusions=None):
if dsn is not None:
self.dsn = dsn
if level is not None:
self.level = level
if logging is not None:
self.logging = logging
if logging_exclusions is None:
self.logging_exclusions = (
'root', 'sanic.access', 'sanic.error')
else:
self.logging_exclusions = logging_exclusions
if not self.client:
self.client = make_client(self.client_cls, app, self.dsn)
if self.logging:
kwargs = {}
if self.logging_exclusions is not None:
kwargs['exclude'] = self.logging_exclusions
handler = SentryHandler(self.client, level=self.level)
setup_logging(handler, **kwargs)
logging_configured.send(
self, sentry_handler=SentryHandler, **kwargs)
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['sentry'] = self
app.error_handler.add(Exception, self.handle_exception)
app.register_middleware(self.before_request, attach_to='request')
app.register_middleware(self.after_request, attach_to='response')
def before_request(self, request):
self.last_event_id = None
try:
self.client.http_context(self.get_http_info(request))
except Exception as e:
self.client.logger.exception(to_unicode(e))
def after_request(self, request, response):
if self.last_event_id:
response.headers['X-Sentry-ID'] = self.last_event_id
self.client.context.clear()
def captureException(self, *args, **kwargs):
assert self.client, 'captureException called before application configured'
result = self.client.captureException(*args, **kwargs)
self.set_last_event_id_from_result(result)
return result
def captureMessage(self, *args, **kwargs):
assert self.client, 'captureMessage called before application configured'
result = self.client.captureMessage(*args, **kwargs)
self.set_last_event_id_from_result(result)
return result
def set_last_event_id_from_result(self, result):
if result:
self.last_event_id = self.client.get_ident(result)
else:
self.last_event_id = None
def user_context(self, *args, **kwargs):
assert self.client, 'user_context called before application configured'
return self.client.user_context(*args, **kwargs)
def tags_context(self, *args, **kwargs):
assert self.client, 'tags_context called before application configured'
return self.client.tags_context(*args, **kwargs)
def extra_context(self, *args, **kwargs):
assert self.client, 'extra_context called before application configured'
return self.client.extra_context(*args, **kwargs)