Beispiel #1
0
def configure_sentry(base_dir, server_env, dsn):
    import sentry_sdk
    from sentry_sdk.integrations.celery import CeleryIntegration
    from sentry_sdk.integrations.django import DjangoIntegration
    from sentry_sdk.integrations.logging import ignore_logger
    from sentry_sdk.integrations.redis import RedisIntegration
    from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration

    def _before_send(event, hint):
        # can't import this during load since settings is not fully configured yet
        from corehq.util.sentry import before_sentry_send
        return before_sentry_send(event, hint)

    release = get_release_name(base_dir, server_env)

    ignore_logger('quickcache')
    ignore_logger('django.template')
    ignore_logger('pillowtop')
    ignore_logger('restore')
    ignore_logger('kafka.conn')

    sentry_sdk.init(dsn,
                    release=release,
                    environment=server_env,
                    request_bodies='never',
                    before_send=_before_send,
                    integrations=[
                        DjangoIntegration(),
                        CeleryIntegration(),
                        SqlalchemyIntegration(),
                        RedisIntegration()
                    ])
Beispiel #2
0
    def setup_once() -> None:

        ignore_logger('tornado.access')

        old_execute = RequestHandler._execute  # type: ignore

        async def sentry_execute_request_handler(self, *args, **kwargs):
            # type: (Any, *Any, **Any) -> Any
            hub = Hub.current

            weak_handler = weakref.ref(self)

            with Hub(hub) as hub:
                with hub.configure_scope() as scope:
                    scope.clear_breadcrumbs()
                    processor = _make_event_processor(weak_handler)
                    scope.add_event_processor(processor)
                return await old_execute(self, *args, **kwargs)

        RequestHandler._execute = sentry_execute_request_handler
        old_log_exception = RequestHandler.log_exception

        def sentry_log_exception(self, ty, value, tb, *args, **kwargs):
            # type: (Any, type, BaseException, Any, *Any, **Any) -> Optional[Any]   # NOQA
            if issubclass(ty, BaseError):
                if value.alert_sentry:
                    _capture_exception(ty, value, tb)
            elif not issubclass(ty, MarshmallowError):
                _capture_exception(ty, value, tb)
            return old_log_exception(self, ty, value, tb)  # type: ignore

        RequestHandler.log_exception = sentry_log_exception  # type: ignore
    def __init__(self, sentry_conn_id="sentry_dsn"):
        ignore_logger("airflow.task")
        ignore_logger("airflow.jobs.backfill_job.BackfillJob")
        executor_name = conf.get("core", "EXECUTOR")

        integrations = [FlaskIntegration(), SqlalchemyIntegration()]

        traces_sample_rate = (1 if os.environ.get("SENTRY_ENABLE_AIRFLOW_APM")
                              in ["true", "True"] else 0)

        try:
            dsn = None
            conn = self.get_connection(sentry_conn_id)
            dsn = get_dsn(conn)
            sentry_sdk.init(
                dsn=dsn,
                integrations=integrations,
                traces_sample_rate=traces_sample_rate,
            )

        except (AirflowException, exc.OperationalError, exc.ProgrammingError):
            self.log.debug("Sentry defaulting to environment variable.")
            sentry_sdk.init(integrations=integrations,
                            traces_sample_rate=traces_sample_rate)

        if traces_sample_rate is 0:
            TaskInstance._run_raw_task = sentry_patched_run_raw_task
        else:
            self.log.debug("Sentry sending APM spans.")
            TaskInstance._run_raw_task = sentry_patched_run_raw_task_with_span

        TaskInstance._sentry_integration_ = True
Beispiel #4
0
def includeme(config):
    """Set up the error tracking service."""
    filters = [
        # Allow functions to be passed as strings: e.g. "module.function"
        config.maybe_dotted(_filter) for _filter in
        config.registry.settings.get("h_pyramid_sentry.filters", [])
    ]

    if asbool(config.registry.settings.get("h_pyramid_sentry.retry_support")):
        # pylint:disable=import-outside-toplevel
        # This is here to lazy load only when required
        from h_pyramid_sentry.filters.pyramid import is_retryable_error

        filters.append(is_retryable_error)
        config.scan("h_pyramid_sentry.subscribers")

    init_options = {**DEFAULT_OPTIONS}
    for key, value in config.registry.settings.items():
        match = OPTION_PATTERN.match(key)
        if match:
            init_options[match.group(1)] = value

    if asbool(config.registry.settings.get("h_pyramid_sentry.celery_support")):
        # pylint:disable=import-outside-toplevel
        # This is here to lazy load only when required
        from sentry_sdk.integrations.celery import CeleryIntegration

        init_options["integrations"].append(CeleryIntegration())

    if asbool(
            config.registry.settings.get(
                "h_pyramid_sentry.sqlalchemy_support")):
        # pylint:disable=import-outside-toplevel
        from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration

        init_options["integrations"].append(SqlalchemyIntegration())

    # exc_logger (which comes from
    # https://docs.pylonsproject.org/projects/pyramid_exclog/) logs all
    # exceptions with log level ERROR, and then all of these get picked up by
    # sentry_sdk's enabled-by-default logging integration
    # (https://docs.sentry.io/platforms/python/logging/).
    #
    # This means that:
    #
    # 1. All exceptions get reported via exc_logger instead of via sentry_sdk's
    # normal route (of intercepting raised exceptions)
    #
    # 2. Some handled exceptions that wouldn't have been reported via the
    # normal route now do get reported because exc_logger logs them as errors.
    #
    # We don't want either of these two things to happen so tell sentry_sdk's
    # logging integration to ignore exc_logger (see
    # https://docs.sentry.io/platforms/python/logging/#ignoring-a-logger).
    #
    # If pyramd_exclog isn't installed this will just have no effect.
    ignore_logger("exc_logger")

    # pylint: disable=abstract-class-instantiated
    sentry_sdk.init(before_send=get_before_send(filters), **init_options)
    def __init__(self):
        """
        Initialize the Sentry SDK.
        """
        ignore_logger("airflow.task")
        ignore_logger("airflow.jobs.backfill_job.BackfillJob")
        executor_name = conf.get("core", "EXECUTOR")

        sentry_flask = FlaskIntegration()

        # LoggingIntegration is set by default.
        integrations = [sentry_flask]

        if executor_name == "CeleryExecutor":
            from sentry_sdk.integrations.celery import CeleryIntegration

            sentry_celery = CeleryIntegration()
            integrations.append(sentry_celery)

        dsn = conf.get("sentry", "sentry_dsn")
        if dsn:
            init(dsn=dsn, integrations=integrations)
        else:
            # Setting up Sentry using environment variables.
            log.debug("Defaulting to SENTRY_DSN in environment.")
            init(integrations=integrations)
Beispiel #6
0
def sentry_logger(conf, name, log_to_console, log_route, fmt, logger,
                  adapted_logger):
    """
    sentry_logger sets up a custom log handler hook for Swift. Its parameters
    are the same as Swift’s get_logger function (as well as the getLogger and
    LogAdapter object).

    The log handler hook is essenitially a no-op, it is called in order to
    initialise Sentry using the init() at the module level.

    We could, of course, set things up by manually adding the Handlers to the
    specific logger (as stated in the Swift docs) but that would result in code
    duplication from the SDK.
    This approach is better since it allows Sentry to capture all events
    instead of just capturing the events from the loggers that Swift gives us
    control over.
    """

    sentry_ignore_loggers = conf.get("sentry_ignore_loggers", None)
    if sentry_ignore_loggers:
        ignore_loggers_list = [
            s.strip() for s in sentry_ignore_loggers.split(",") if s.strip()
        ]
        for lgr in ignore_loggers_list:
            ignore_logger(lgr)
Beispiel #7
0
def configure(**sentry_sdk_init_kwargs):
    for logger in IGNORE_LOGGERS:
        ignore_logger(logger)

    logging_integration = LoggingIntegration()
    attr_map = [
        StructlogAwareMessageFormatter.AttrMapItem(
            record_attr_name='request_id',
            event_dict_key='request_id',
            default_value=None)
    ]

    # We attach our structlog aware formatter to sentry logging handlers
    for attr_name, attr_value in vars(logging_integration).items():
        if isinstance(attr_value, logging.Handler):
            # we have to pass copy_record False because Sentry handler expects inplace formatting
            # Fortunately, Sentry's handlers are called last in chain
            attr_value.setFormatter(
                StructlogAwareMessageFormatter(copy_record=False,
                                               attr_map=attr_map))

    sentry_sdk.init(dsn=SENTRY_DSN,
                    integrations=[DjangoIntegration(), logging_integration],
                    environment=ENVIRONMENT,
                    **sentry_sdk_init_kwargs)
Beispiel #8
0
    def setup_once():
        # type: () -> None
        import celery.app.trace as trace  # type: ignore

        old_build_tracer = trace.build_tracer

        def sentry_build_tracer(name, task, *args, **kwargs):
            if not getattr(task, "_sentry_is_patched", False):
                # Need to patch both methods because older celery sometimes
                # short-circuits to task.run if it thinks it's safe.
                task.__call__ = _wrap_task_call(task, task.__call__)
                task.run = _wrap_task_call(task, task.run)
                task.apply_async = _wrap_apply_async(task, task.apply_async)

                # `build_tracer` is apparently called for every task
                # invocation. Can't wrap every celery task for every invocation
                # or we will get infinitely nested wrapper functions.
                task._sentry_is_patched = True

            return _wrap_tracer(task,
                                old_build_tracer(name, task, *args, **kwargs))

        trace.build_tracer = sentry_build_tracer

        _patch_worker_exit()

        # This logger logs every status of every task that ran on the worker.
        # Meaning that every task's breadcrumbs are full of stuff like "Task
        # <foo> raised unexpected <bar>".
        ignore_logger("celery.worker.job")
        ignore_logger("celery.app.trace")
Beispiel #9
0
    def __init__(self, config):
        self.config = config

        dsn = config.SENTRY_DSN_URL

        if not dsn:
            raise RuntimeError("""
If you set USE_CUSTOM_ERROR_HANDLING to True, and you
are using thumbor.error_handlers.sentry,
then you must specify the Sentry DSN using the
SENTRY_DSN_URL configuration."
                """)

        kwargs = {
            "dsn": dsn,
            "integrations": [],
        }

        env = config.get("SENTRY_ENVIRONMENT")
        if env is not None:
            kwargs["environment"] = env

        # Logging integration will create duplicates if below not ignored
        ignore_logger("thumbor")
        ignore_logger("tornado.access")

        sentry_sdk.init(**kwargs)
Beispiel #10
0
    def __init__(self, sentry_conn_id=None):
        ignore_logger("airflow.task")
        ignore_logger("airflow.jobs.backfill_job.BackfillJob")
        executor_name = conf.get("core", "EXECUTOR")

        sentry_flask = FlaskIntegration()
        integrations = [sentry_flask]

        if executor_name == "CeleryExecutor":
            from sentry_sdk.integrations.celery import CeleryIntegration

            sentry_celery = CeleryIntegration()
            integrations += [sentry_celery]

        try:
            conn_id = None
            dsn = None
            if sentry_conn_id is None:
                conn_id = self.get_connection("sentry_dsn")
            else:
                conn_id = self.get_connection(sentry_conn_id)
            dsn = conn_id.host
            init(dsn=dsn, integrations=integrations)
        except (AirflowException, exc.OperationalError, exc.ProgrammingError):
            self.log.debug("Sentry defaulting to environment variable.")
            init(integrations=integrations)

        TaskInstance._run_raw_task = add_sentry
        TaskInstance._sentry_integration_ = True
Beispiel #11
0
def install_sql_hook():
    # type: () -> None
    """If installed this causes Django's queries to be captured."""
    try:
        from django.db.backends.utils import CursorWrapper  # type: ignore
    except ImportError:
        from django.db.backends.util import CursorWrapper  # type: ignore

    try:
        real_execute = CursorWrapper.execute
        real_executemany = CursorWrapper.executemany
    except AttributeError:
        # This won't work on Django versions < 1.6
        return

    def record_many_sql(sql, param_list):
        for params in param_list:
            record_sql(sql, params)

    def execute(self, sql, params=None):
        try:
            return real_execute(self, sql, params)
        finally:
            record_sql(sql, params)

    def executemany(self, sql, param_list):
        try:
            return real_executemany(self, sql, param_list)
        finally:
            record_many_sql(sql, param_list)

    CursorWrapper.execute = execute
    CursorWrapper.executemany = executemany
    ignore_logger("django.db.backends")
Beispiel #12
0
def setup_sentry(app: FastAPI):
    if config.DSN:  # pragma: no cover
        ignore_logger("asyncio")
        logger.debug("setup sentry")
        sentry_sdk.init(dsn=config.DSN,
                        release=config.COMMIT_SHA,
                        integrations=[RedisIntegration()])
        app.add_middleware(SentryAsgiMiddleware)
Beispiel #13
0
def SENTRY_INIT(dsn: str, sentry_opts: dict):
    """Init function for sentry.

    Will only be called if SENTRY_DSN is not None, during core start, can be
    overriden in separate settings file.
    """
    sentry_sdk.init(dsn, **sentry_opts)
    ignore_logger("graphql.execution.utils")
def ignore_graphene_logger():
    """
    A utils function that can be called to ignore a graphene logger that logs errors as strings instead of errors.
    This leads to a loss of Sentry's features. Instead, you can report the original exception.

    Test for:
        * sentry_sdk >= 0.13.0
    """
    ignore_logger('graphql.execution.utils')
Beispiel #15
0
    def setup_once():
        task_prerun.connect(_handle_task_prerun, weak=False)
        task_postrun.connect(_handle_task_postrun, weak=False)
        task_failure.connect(_process_failure_signal, weak=False)

        # This logger logs every status of every task that ran on the worker.
        # Meaning that every task's breadcrumbs are full of stuff like "Task
        # <foo> raised unexpected <bar>".
        ignore_logger("celery.worker.job")
Beispiel #16
0
def test_ignore_logger(sentry_init, capture_events):
    sentry_init(integrations=[LoggingIntegration()],
                default_integrations=False)
    events = capture_events()

    ignore_logger("testfoo")

    other_logger.error("hi")

    assert not events
Beispiel #17
0
def configure_sentry(ignore_logger, sentry_sdk):
    ignore_logger(LOGGER_NAME)
    config = configparser.ConfigParser()
    config.read(APP_CONFIG)

    env = "development" if os.environ.get(
        "protonvpn_env") else "production"  # noqa

    sentry_sdk.init(dsn=config["sentry"]["dsn"],
                    ignore_errors=["KeyboardInterrupt"],
                    release="protonvpn-nm-core@" + APP_VERSION,
                    environment=env)
Beispiel #18
0
def initialize_sentry(config):
    """  Setup an instance of :class:`sentry_sdk.Client`.
        :param config: Sentry configuration
        :param client: class used to instantiate the sentry_sdk client.
    """
    enabled = config.get("sentry_enabled", False)
    if not (HAS_SENTRY_SDK and enabled):
        return
    _logger.info("Initializing sentry...")
    if config.get("sentry_odoo_dir") and config.get("sentry_release"):
        _logger.debug("Both sentry_odoo_dir and \
                       sentry_release defined, choosing sentry_release")
    options = {
        "release": config.get("sentry_release",
                              get_odoo_commit(config.get("sentry_odoo_dir"))),
    }
    for option in const.get_sentry_options():
        value = config.get('sentry_%s' % option.key, option.default)
        if isinstance(option.converter, collections.Callable):
            value = option.converter(value)
        options[option.key] = value

    exclude_loggers = const.split_multiple(
        config.get("sentry_exclude_loggers", const.DEFAULT_EXCLUDE_LOGGERS)
    )
    # Change name `ignore_exceptions` (with raven)
    # to `ignore_errors' (sentry_sdk)
    options["ignore_errors"] = options["ignore_exceptions"]
    del options["ignore_exceptions"]

    options["before_send"] = before_send

    options["integrations"] = [options["logging_level"],
                               ThreadingIntegration(propagate_hub=True)]
    # Remove logging_level, since in sentry_sdk is include in 'integrations'
    del options["logging_level"]

    client = sentry_sdk.init(**options)

    sentry_sdk.set_tag("include_context",
                       config.get("sentry_include_context", True))

    if exclude_loggers:
        for item in exclude_loggers:
            ignore_logger(item)

    wsgi_server.application = SentryWsgiMiddleware(wsgi_server.application)

    with sentry_sdk.push_scope() as scope:
        scope.set_extra("debug", False)
        sentry_sdk.capture_message("Starting Odoo Server", "info")

    return client
Beispiel #19
0
def init_error_collection(celery=False):
    if settings.SENTRY_DSN:
        sentry_sdk.init(
            dsn=settings.SENTRY_DSN,
            integrations=[CeleryIntegration(), DjangoIntegration(), RedisIntegration()],
            send_default_pii=True,
            release=weblate.GIT_REVISION or weblate.VERSION,
        )
        ignore_logger("weblate.celery")

    if celery and HAS_ROLLBAR and hasattr(settings, 'ROLLBAR'):
        rollbar.init(**settings.ROLLBAR)
        rollbar.BASE_DATA_HOOK = celery_base_data_hook
Beispiel #20
0
    def from_crawler(cls, crawler):
        """
        Initialize the extension from a crawler instance and connect
        to the `spider_error` signal.
        """
        extension = cls()
        crawler.signals.connect(extension.spider_error,
                                signal=signals.spider_error)

        # ignore sentry logger
        ignore_logger('scrapy.core.scraper')

        return extension
Beispiel #21
0
    def init_sentry(self):
        # sentry log handler
        sentry_logging = LoggingIntegration(
            level=logging.INFO,  # Capture info and above as breadcrumbs
            event_level=logging.ERROR  # Send errors as events
        )

        # init sentry logging
        sentry_sdk.init(
            dsn="https://[email protected]/2?verify_ssl=0",
            integrations=[sentry_logging],
            release=sickrage.version(),
            environment=('master', 'develop')['dev' in sickrage.version()],
            ignore_errors=[
                'KeyboardInterrupt',
                'PermissionError',
                'FileNotFoundError',
                'EpisodeNotFoundException'
            ]
        )

        # sentry tags
        sentry_tags = {
            'platform': platform.platform(),
            'locale': repr(locale.getdefaultlocale()),
            'python': platform.python_version(),
            'install_type': sickrage.install_type()
        }

        # set sentry tags
        for tag_key, tag_value in sentry_tags.items():
            sentry_sdk.set_tag(tag_key, tag_value)

        # set loggers to ignore
        ignored_loggers = [
            'enzyme.parsers.ebml.core',
            'subliminal.core',
            'subliminal.utils',
            'subliminal.refiners.tvdb',
            'subliminal.refiners.metadata',
            'subliminal.providers.tvsubtitles',
            'pika.connection',
            'pika.adapters.base_connection',
            'pika.adapters.utils.io_services_utils',
            'pika.adapters.utils.connection_workflow',
            'pika.adapters.utils.selector_ioloop_adapter'
        ]

        for item in ignored_loggers:
            ignore_logger(item)
Beispiel #22
0
    def init(self,
             sentry_url='',
             release_version='',
             scrubber=None,
             strategy=SentryStrategy.SEND_ALLOWED_WITH_CONFIRMATION):
        """Initialization.

        This method should be called in each process that uses SentryReporter.

        Args:
            sentry_url: URL for Sentry server. If it is empty then Sentry's
                sending mechanism will not be initialized.

            scrubber: a class that will be used for scrubbing sending events.
                Only a single method should be implemented in the class:
                ```
                    def scrub_event(self, event):
                        pass
                ```
            release_version: string that represents a release version.
                See Also: https://docs.sentry.io/platforms/python/configuration/releases/
            strategy: a Sentry strategy for sending events (see class Strategy
                for more information)
        Returns:
            Sentry Guard.
        """
        self._logger.debug(f"Init: {sentry_url}")
        self.scrubber = scrubber
        self.global_strategy = strategy

        rv = sentry_sdk.init(
            sentry_url,
            release=release_version,
            # https://docs.sentry.io/platforms/python/configuration/integrations/
            integrations=[
                LoggingIntegration(
                    level=logging.
                    INFO,  # Capture info and above as breadcrumbs
                    event_level=None,  # Send no errors as events
                ),
                ThreadingIntegration(propagate_hub=True),
            ],
            before_send=self._before_send,
            ignore_errors=[KeyboardInterrupt],
        )

        ignore_logger(self._sentry_logger_name)

        return rv
def hijack_loggers(loggers, level=logging.INFO):
    """
    Context manager to temporarily set the handler
    of each logger in `loggers`.

    Parameters
    ----------
    loggers: list of str
        Loggers to change
    level: logging LEVEL int
        Level to set the temporary handler to

    Returns
    -------
    ListHandler
        The handler that will be temporarily assigned
        to each logger.

    Notes
    -----
    This may not capture all records when used in a
    distributed or multiprocessing workflow
    """
    handler = ListHandler()
    handler.setLevel(level)

    all_loggers = set()
    for name in loggers:
        all_loggers.add(name)
        all_loggers |= _get_children(name)

    logger_info = {}
    for name in all_loggers:
        logger = logging.getLogger(name)
        logger_info[name] = (logger.handlers, logger.propagate)
        logger.handlers = [handler]
        sentry_logging.ignore_logger(name)
        logger.propagate = False
    yield handler
    for name in all_loggers:
        logger = logging.getLogger(name)
        hnd, prop = logger_info[name]
        logger.handlers = hnd
        logger.propagate = prop
        try:
            sentry_logging._IGNORED_LOGGERS.remove(name)
        except Exception:
            pass
    del handler
Beispiel #24
0
def test_ignore_logger_wildcard(sentry_init, capture_events):
    sentry_init(integrations=[LoggingIntegration()],
                default_integrations=False)
    events = capture_events()

    ignore_logger("testfoo.*")

    nested_logger = logging.getLogger("testfoo.submodule")

    logger.error("hi")

    nested_logger.error("bye")

    (event, ) = events
    assert event["logentry"]["message"] == "hi"
Beispiel #25
0
def init_error_collection(celery=False):
    if settings.SENTRY_DSN:
        sentry_sdk.init(
            dsn=settings.SENTRY_DSN,
            integrations=[CeleryIntegration(), DjangoIntegration(), RedisIntegration()],
            send_default_pii=True,
            release=weblate.GIT_REVISION or weblate.TAG_NAME,
            environment=settings.SENTRY_ENVIRONMENT,
            **settings.SENTRY_EXTRA_ARGS,
        )
        # Ignore Weblate logging, those are reported using capture_exception
        ignore_logger(ERROR_LOGGER)

    if celery and HAS_ROLLBAR and hasattr(settings, "ROLLBAR"):
        rollbar.init(**settings.ROLLBAR)
        rollbar.BASE_DATA_HOOK = celery_base_data_hook
Beispiel #26
0
def sdk_init(global_conf,
             dsn,
             level='INFO',
             event_level='ERROR',
             ignorelist=''):
    sentry_logging = LoggingIntegration(
        level=logging.__dict__[level],
        event_level=logging.__dict__[event_level])
    for logger in ignorelist.split():
        ignore_logger(logger)

    def filter(app):
        sentry_sdk.init(dsn=dsn, integrations=[sentry_logging])
        return app

    return filter
Beispiel #27
0
def init_app(app, testmode=False):
    # We load configurations first from the config file (where some options
    # are overridable via environment variables) or from the config file
    # pointed to by the MEASUREMENTS_CONFIG environment variable.
    # The later overrides the former.
    app.config.from_object("measurements.config")
    app.config.from_envvar("MEASUREMENTS_CONFIG", silent=True)

    # Prevent messy duplicate logs during testing
    if not testmode:
        app.logger.addHandler(logging.StreamHandler())

    if app.config["APP_ENV"] == "production":
        app.logger.setLevel(logging.WARNING)
    elif app.config["APP_ENV"] == "development":
        app.logger.setLevel(logging.DEBUG)
        # Set the jinja templates to reload when in development
        app.jinja_env.auto_reload = True
        app.config["TEMPLATES_AUTO_RELOAD"] = True
        app.config["DEBUG"] = True
    elif app.config["APP_ENV"] not in (
            "testing",
            "staging",
    ):  # known envs according to Readme.md
        raise RuntimeError("Unexpected APP_ENV", app.config["APP_ENV"])

    for key in app.config.keys():
        SECRET_SUBSTRINGS = ["_SECRET_", "DATABASE_URL"]
        # Do not log, even in debug, anything containing the word "SECRET" or "DATABASE_URL"
        if any([s in key for s in SECRET_SUBSTRINGS]):
            continue
        app.logger.debug("{}: {}".format(key, app.config[key]))

    if app.config["APP_ENV"] == "production":
        sentry_sdk.init(
            dsn="https://[email protected]/1367288",
            integrations=[FlaskIntegration()],
        )
        # TODO Temporary workaround to ignore flask-limiter logs due to:
        # https://github.com/ooni/api/issues/145 &
        # https://github.com/alisaifee/flask-limiter/issues/186
        ignore_logger("flask-limiter")

    md = Misaka(fenced_code=True)
    md.init_app(app)

    CORS(app, resources={r"/api/*": {"origins": "*"}})
Beispiel #28
0
    def setup_once():
        # type: () -> None
        if TORNADO_VERSION < (5, 0):
            raise DidNotEnable("Tornado 5+ required")

        if not HAS_REAL_CONTEXTVARS:
            # Tornado is async. We better have contextvars or we're going to leak
            # state between requests.
            raise DidNotEnable(
                "The tornado integration for Sentry requires Python 3.7+ or the aiocontextvars package"
                + CONTEXTVARS_ERROR_MESSAGE
            )

        ignore_logger("tornado.access")

        old_execute = RequestHandler._execute  # type: ignore

        awaitable = iscoroutinefunction(old_execute)

        if awaitable:
            # Starting Tornado 6 RequestHandler._execute method is a standard Python coroutine (async/await)
            # In that case our method should be a coroutine function too
            async def sentry_execute_request_handler(self, *args, **kwargs):
                # type: (RequestHandler, *Any, **Any) -> Any
                with _handle_request_impl(self):
                    return await old_execute(self, *args, **kwargs)

        else:

            @coroutine  # type: ignore
            def sentry_execute_request_handler(self, *args, **kwargs):  # type: ignore
                # type: (RequestHandler, *Any, **Any) -> Any
                with _handle_request_impl(self):
                    result = yield from old_execute(self, *args, **kwargs)
                    return result

        RequestHandler._execute = sentry_execute_request_handler  # type: ignore

        old_log_exception = RequestHandler.log_exception

        def sentry_log_exception(self, ty, value, tb, *args, **kwargs):
            # type: (Any, type, BaseException, Any, *Any, **Any) -> Optional[Any]
            _capture_exception(ty, value, tb)
            return old_log_exception(self, ty, value, tb, *args, **kwargs)  # type: ignore

        RequestHandler.log_exception = sentry_log_exception  # type: ignore
Beispiel #29
0
    def __init__(self, sentry_url):
        self.sentry_client = None

        if not sentry_url:
            return

        kwargs = {
            "dsn": sentry_url,
            "integrations": [],
        }

        # Logging integration will create duplicates if below not ignored
        ignore_logger("thumbor")
        ignore_logger("tornado.access")

        sentry_sdk.init(**kwargs)
        self.install_handler()
Beispiel #30
0
def install_sql_hook():
    # type: () -> None
    """If installed this causes Django's queries to be captured."""
    try:
        from django.db.backends.utils import CursorWrapper
    except ImportError:
        from django.db.backends.util import CursorWrapper

    try:
        real_execute = CursorWrapper.execute
        real_executemany = CursorWrapper.executemany
    except AttributeError:
        # This won't work on Django versions < 1.6
        return

    def execute(self, sql, params=None):
        # type: (CursorWrapper, Any, Optional[Any]) -> Any
        hub = Hub.current
        if hub.get_integration(DjangoIntegration) is None:
            return real_execute(self, sql, params)

        with record_sql_queries(hub,
                                self.cursor,
                                sql,
                                params,
                                paramstyle="format",
                                executemany=False):
            return real_execute(self, sql, params)

    def executemany(self, sql, param_list):
        # type: (CursorWrapper, Any, List[Any]) -> Any
        hub = Hub.current
        if hub.get_integration(DjangoIntegration) is None:
            return real_executemany(self, sql, param_list)

        with record_sql_queries(hub,
                                self.cursor,
                                sql,
                                param_list,
                                paramstyle="format",
                                executemany=True):
            return real_executemany(self, sql, param_list)

    CursorWrapper.execute = execute
    CursorWrapper.executemany = executemany
    ignore_logger("django.db.backends")
Beispiel #31
0
    sentry_sdk.init(
        dsn=config.get('sentry', 'dsn'),
        integrations=[
            PretixSentryIntegration(),
            CeleryIntegration(),
            LoggingIntegration(
                level=logging.INFO,
                event_level=logging.CRITICAL
            )
        ],
        environment=SITE_URL,
        release=__version__,
        send_default_pii=False,

    )
    ignore_logger('pretix.base.tasks')
    ignore_logger('django.security.DisallowedHost')
    setup_custom_filters()

CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TASK_DEFAULT_QUEUE = 'default'
CELERY_TASK_QUEUES = (
    Queue('default', routing_key='default.#'),
    Queue('checkout', routing_key='checkout.#'),
    Queue('mail', routing_key='mail.#'),
    Queue('background', routing_key='background.#'),
    Queue('notifications', routing_key='notifications.#'),
)
CELERY_TASK_ROUTES = ([
    ('pretix.base.services.cart.*', {'queue': 'checkout'}),