ZerethShell — File Manager

sanic.py

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

Vazgeç