def register_handlers():
from django.core.signals import got_request_exception
# HACK: support Sentry's internal communication
if 'sentry' in django_settings.INSTALLED_APPS:
from django.db import transaction
@transaction.commit_on_success
def wrap_sentry(request, **kwargs):
if transaction.is_dirty():
transaction.rollback()
return sentry_exception_handler(request, **kwargs)
exception_handler = wrap_sentry
else:
exception_handler = sentry_exception_handler
# Connect to Django's internal signal handler
got_request_exception.connect(exception_handler)
# If Celery is installed, register a signal handler
if 'djcelery' in django_settings.INSTALLED_APPS:
from raven.contrib.celery import register_signal, register_logger_signal
try:
register_signal(client)
except Exception:
logger.exception('Failed installing error handling for Celery')
try:
register_logger_signal(client)
except Exception:
logger.exception('Failed installing logging handler for Celery')
def make_celery(app, celery):
""" From http://flask.pocoo.org/docs/0.10/patterns/celery/ """
# Register our custom serializer type before updating the configuration.
from kombu.serialization import register
from doorman.celery_serializer import djson_dumps, djson_loads
register(
'djson', djson_dumps, djson_loads,
content_type='application/x-djson',
content_encoding='utf-8'
)
# Actually update the config
celery.config_from_object(app.config)
# Register Sentry client
if 'SENTRY_DSN' in app.config and app.config['SENTRY_DSN']:
client = Client(app.config['SENTRY_DSN'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def init_celery():
"""
Initialize Celery, and make our app instance available as `celery_app`
for use by the `celery` command.
"""
from django.conf import settings
from raven import Client
from raven.contrib.celery import register_signal, register_logger_signal
from amo import celery
# I think `manage.py celery` relies on this global? We typically don't run
# celery like that anymore though.
global celery_app
celery_app = celery.app
# Hook up Sentry in celery.
client = Client(settings.SENTRY_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
# After upgrading raven we can specify loglevel=logging.INFO to override
# the default (which is ERROR).
register_logger_signal(client)
def configure_error_handling(sender, **kargs):
"""Rollbar and Sentry integration
Based on
https://www.mattlayman.com/blog/2017/django-celery-rollbar/
"""
if not bool(os.environ.get('CELERY_WORKER_RUNNING', False)):
return
from django.conf import settings
if HAS_ROLLBAR and hasattr(settings, 'ROLLBAR'):
rollbar.init(**settings.ROLLBAR)
def celery_base_data_hook(request, data):
data['framework'] = 'celery'
rollbar.BASE_DATA_HOOK = celery_base_data_hook
@task_failure.connect
def handle_task_failure(**kw):
rollbar.report_exc_info(extra_data=kw)
if HAS_RAVEN and hasattr(settings, 'RAVEN_CONFIG'):
client = Client(
settings.RAVEN_CONFIG['dsn'],
release=settings.RAVEN_CONFIG.get('release'),
environment=settings.RAVEN_CONFIG.get('environment'),
)
register_signal(client, ignore_expected=True)
register_logger_signal(client, loglevel=logging.ERROR)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
celery.conf.update(app.config)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
if not app.config['DEBUG']:
# https://docs.getsentry.com/hosted/clients/python/integrations/flask/
sentry.init_app(app, dsn=app.config['SENTRY_DSN'])
# https://docs.getsentry.com/hosted/clients/python/integrations/celery/
client = Client(app.config['SENTRY_DSN'])
register_logger_signal(client)
register_signal(client)
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .api_v1 import api_module as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .public import public as public_blueprint
app.register_blueprint(public_blueprint)
return app
def create_celery_app(app=None, config="worker"):
"""
adapted from http://flask.pocoo.org/docs/0.10/patterns/celery/
(added the wsgi_environ stuff)
"""
app = app or create_app(config=config)
celery.main = app.import_name
celery.conf["BROKER_URL"] = app.config["CELERY_BROKER_URL"]
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
if "wsgi_environ" in kwargs:
wsgi_environ = kwargs.pop("wsgi_environ")
else:
wsgi_environ = None
with app.app_context():
if wsgi_environ:
with app.request_context(wsgi_environ):
return TaskBase.__call__(self, *args, **kwargs)
else:
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
register_logger_signal(sentry.client)
register_signal(sentry.client)
return celery
def on_configure(self):
if 'raven.contrib.django.raven_compat' in settings.INSTALLED_APPS:
client = raven.Client(**settings.RAVEN_CONFIG)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def bootstrap_worker(sender, **kwargs):
request = sender.app.webapp_bootstrap()
sender.app.request = request
# Configure Sentry reporting on task failure
register_signal(request.sentry)
register_logger_signal(request.sentry, loglevel=logging.ERROR)
def on_configure(self):
if hasattr(settings, 'RAVEN_CONFIG') and settings.RAVEN_CONFIG['dsn']:
import raven
from raven.contrib.celery import (register_signal,
register_logger_signal)
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
register_logger_signal(client)
register_signal(client)
def __init__(self, app):
if app.config.get('SENTRY_DSN'):
app.config.setdefault('SENTRY_NAME', app.config.get('SERVER_NAME'))
self.sentry = Sentry(app, register_signal=False, wrap_wsgi=False, logging=True, level=logging.WARNING)
register_logger_signal(self.sentry.client)
register_signal(self.sentry.client)
else:
self.sentry = None
def on_configure(self):
client = RavenClient(SETTINGS.get('sentry_dsn'))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = raven.Client(settings.RAVEN_URL)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def init_app(self, app):
self.app = app
self.config_from_object(app.config)
if 'SENTRY_DSN' in app.config and app.config['SENTRY_DSN'] is not None:
self.sentry = raven.Client(app.config['SENTRY_DSN'])
register_logger_signal(self.sentry)
register_signal(self.sentry)
def on_configure(self):
client = raven.Client(SENTRY_LINK)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if settings.SENTRY_ENABLED:
import raven
from raven.contrib.celery import register_signal, register_logger_signal
client = raven.Client(settings.RAVEN_CONFIG["dsn"])
register_logger_signal(client)
register_signal(client)
def init_sentry():
""" Inject Sentry logging into Celery."""
from raven import Client
from raven.contrib.celery import register_signal, register_logger_signal
import logging
client = Client()
register_logger_signal(client, loglevel=logging.ERROR)
register_signal(client, ignore_expected=True)
def on_configure(self):
if not getattr(settings, 'CELERY_RAVEN_DSN', None):
# for no send raven reports from dev server
return
client = raven.Client(settings.CELERY_RAVEN_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self): # pylint: disable=method-hidden
if not client:
return
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
# Import has to be relative. "client" is not actually lazily initialized
from raven.contrib.django.raven_compat.models import client
if not client.is_enabled():
return
register_signal(client)
register_logger_signal(client)
def on_configure(self):
if settings.SENTRY_DSN:
client = raven.Client(settings.SENTRY_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = Client('https://*****:*****@app.getsentry.com/71566')
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if not client:
return
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if hasattr(settings, 'RAVEN_CONFIG') and settings.RAVEN_CONFIG['dsn']:
import raven
from raven.contrib.celery import (register_signal,
register_logger_signal)
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
register_logger_signal(client)
register_signal(client)
def on_configure(self):
from raven.contrib.django.models import client
from raven.contrib.celery import register_signal, register_logger_signal
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
from raven.contrib.django.models import client
from raven.contrib.celery import register_signal, register_logger_signal
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if getattr(settings, 'RAVEN_CONFIG', None):
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if not getattr(settings, 'CELERY_RAVEN_DSN'):
# for no send raven reports from dev server
return
client = raven.Client(settings.CELERY_RAVEN_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = raven.Client(os.getenv('SENTRY_DSN'), environment=os.getenv('SENTRY_ENVIRONMENT'))
# Always ensure you import register_logger_signal, register_signal and not their parent modules
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if os.environ.get('SENTRY_DSN'):
client = raven.Client(os.environ.get('SENTRY_DSN'))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if settings.PDB_ENABLE_SENTRY: # ignore for coverage
client = raven.Client(settings.PDB_SENTRY_DSN)
client.release = raven.fetch_git_sha(os.path.dirname(os.pardir))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = raven.Client(
'https://*****:*****@sentry.trailblazingtech.com/3'
)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
dsn = settings.RAVEN_CONFIG.get('dsn')
if dsn:
client = raven.Client(dsn)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = raven.Client(
'https://*****:*****@sentry.io/1314513' # noqa
)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
"""Update raven client"""
try:
client = Client(settings.RAVEN_CONFIG.get('dsn'))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
except RecursionError: # This error happens when pdoc is running
pass
def configure_sentry(dsn=None):
dsn = dsn or getenv("SENTRY_DSN")
if not dsn:
return
client = Client(dsn)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if settings.PDB_ENABLE_SENTRY: # ignore for coverage
client = raven.Client(settings.PDB_SENTRY_DSN)
client.release = raven.fetch_git_sha(os.path.dirname(os.pardir))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
client = raven.Client(
'https://*****:*****@sentry.io/717191'
)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if os.environ.get("RAVEN_DSN") and not os.environ.get("CI_BUILD_REF"):
client = raven.Client(os.environ["RAVEN_DSN"])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if self.sentry_dsn:
client = Client(self.sentry_dsn)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
add_sentry_handler_to_celery_task_logger(client, self.sentry_handler_log_level)
def on_configure(self):
try:
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
except AttributeError:
pass
def init_sentry():
logger.debug('Initializing Sentry loghandler')
client = LambdaClient(auto_log_stacks=True)
loghandler = SentryHandler(client)
loghandler.setLevel('ERROR')
setup_logging(loghandler)
logger.debug('Applying Sentry celery signals and logging hooks')
register_logger_signal(client, loglevel=logging.INFO)
register_signal(client, ignore_expected=False)
return client
def on_configure(self):
try:
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
except AttributeError:
pass
def install_handler(self, app):
"""Install log handler."""
from raven.conf import EXCLUDE_LOGGER_DEFAULTS
from raven.contrib.celery import register_logger_signal, \
register_signal
from raven.contrib.flask import Sentry, make_client
from raven.handlers.logging import SentryHandler
# Installs sentry in app.extensions['sentry']
level = getattr(logging, app.config['LOGGING_SENTRY_LEVEL'])
logging_exclusions = None
if not app.config['LOGGING_SENTRY_PYWARNINGS']:
logging_exclusions = list(EXCLUDE_LOGGER_DEFAULTS)
logging_exclusions.append('py.warnings')
# Get the Sentry class.
cls = app.config['LOGGING_SENTRY_CLASS']
if cls:
if isinstance(cls, six.string_types):
cls = import_string(cls)
else:
cls = Sentry
sentry = cls(
app,
logging=True,
level=level,
logging_exclusions=logging_exclusions,
)
app.logger.addHandler(SentryHandler(client=sentry.client, level=level))
# Capture warnings from warnings module
if app.config['LOGGING_SENTRY_PYWARNINGS']:
self.capture_pywarnings(SentryHandler(sentry.client))
# Setup Celery logging to Sentry
if app.config['LOGGING_SENTRY_CELERY']:
try:
register_logger_signal(sentry.client, loglevel=level)
except TypeError:
# Compatibility mode for Raven<=5.1.0
register_logger_signal(sentry.client)
register_signal(sentry.client)
# Werkzeug only adds a stream handler if there's no other handlers
# defined, so when Sentry adds a log handler no output is
# received from Werkzeug unless we install a console handler
# here on the werkzeug logger.
if app.debug:
logger = logging.getLogger('werkzeug')
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())
def _configure_sentry(self, raven_config):
import raven
from raven.contrib.celery import (register_signal,
register_logger_signal)
client = raven.Client(**raven_config)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
sentry_dsn = getattr(settings, 'SENTRY_DSN', None)
if sentry_dsn is None:
return super(MyCelery, self).on_configure()
client = raven.Client(sentry_dsn)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if os.environ.get('RAVEN_ENABLED'):
client = raven.Client(
'https://*****:*****@sentry.io/1164181'
)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
import raven
from raven.contrib.celery import register_signal, register_logger_signal
client = raven.Client()
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
sentry_dsn = getattr(settings, 'SENTRY_DSN', None)
if sentry_dsn is None:
return super(MyCelery, self).on_configure()
client = raven.Client(sentry_dsn)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
import raven
from raven.contrib.celery import register_signal, register_logger_signal
client = raven.Client()
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
if not RAVEN_DSN:
return
client = raven.Client(RAVEN_DSN)
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def on_configure(self):
"""Set up sentry client."""
dsn = os.environ.get("SENTRY_DSN")
client = raven.Client(dsn)
register_logger_signal(client)
register_signal(client)
client.ignore_exceptions = [
"f8a_worker.errors.NotABugFatalTaskError",
"f8a_worker.errors.NotABugTaskError",
"f8a_worker.errors.TaskAlreadyExistsError"
]
def on_configure(self):
client = raven.Client(
sentry_url,
auto_log_stacks=True # add detailed stack_trace
)
# register a custom filter to filter out
# duplicate logs
register_logger_signal(client)
# hook into the
# Celery error
# handler
register_signal(client)
def on_configure(self): # pylint: disable=method-hidden
"""
Register Sentry for celery tasks.
"""
if getattr(settings, 'RAVEN_CONFIG', None):
client = raven.Client(settings.RAVEN_CONFIG['dsn'])
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def register_handlers():
from django.core.signals import got_request_exception, request_started
def before_request(*args, **kwargs):
client.context.activate()
request_started.connect(before_request, weak=False)
# HACK: support Sentry's internal communication
if 'sentry' in settings.INSTALLED_APPS:
from django.db import transaction
# Django 1.6
if hasattr(transaction, 'atomic'):
commit_on_success = transaction.atomic
else:
commit_on_success = transaction.commit_on_success
@commit_on_success
def wrap_sentry(request, **kwargs):
if transaction.is_dirty():
transaction.rollback()
return sentry_exception_handler(request, **kwargs)
exception_handler = wrap_sentry
else:
exception_handler = sentry_exception_handler
# Connect to Django's internal signal handler
got_request_exception.connect(exception_handler, weak=False)
# If Celery is installed, register a signal handler
if 'djcelery' in settings.INSTALLED_APPS:
try:
# Celery < 2.5? is not supported
from raven.contrib.celery import (register_signal,
register_logger_signal)
except ImportError:
logger.exception('Failed to install Celery error handler')
else:
try:
register_signal(client)
except Exception:
logger.exception('Failed to install Celery error handler')
try:
ga = lambda x, d=None: getattr(settings, 'SENTRY_%s' % x, d)
options = getattr(settings, 'RAVEN_CONFIG', {})
loglevel = options.get('celery_loglevel',
ga('CELERY_LOGLEVEL', logging.ERROR))
register_logger_signal(client, loglevel=loglevel)
except Exception:
logger.exception('Failed to install Celery error handler')
def register_handlers():
from django.core.signals import got_request_exception, request_started
def before_request(*args, **kwargs):
client.context.activate()
request_started.connect(before_request, weak=False)
# HACK: support Sentry's internal communication
if 'sentry' in settings.INSTALLED_APPS:
from django.db import transaction
# Django 1.6
if hasattr(transaction, 'atomic'):
commit_on_success = transaction.atomic
else:
commit_on_success = transaction.commit_on_success
@commit_on_success
def wrap_sentry(request, **kwargs):
if transaction.is_dirty():
transaction.rollback()
return sentry_exception_handler(request, **kwargs)
exception_handler = wrap_sentry
else:
exception_handler = sentry_exception_handler
# Connect to Django's internal signal handler
got_request_exception.connect(exception_handler, weak=False)
# If Celery is installed, register a signal handler
if 'djcelery' in settings.INSTALLED_APPS:
try:
# Celery < 2.5? is not supported
from raven.contrib.celery import (
register_signal, register_logger_signal)
except ImportError:
logger.exception('Failed to install Celery error handler')
else:
try:
register_signal(client)
except Exception:
logger.exception('Failed to install Celery error handler')
try:
ga = lambda x, d=None: getattr(settings, 'SENTRY_%s' % x, d)
options = getattr(settings, 'RAVEN_CONFIG', {})
loglevel = options.get('celery_loglevel',
ga('CELERY_LOGLEVEL', logging.ERROR))
register_logger_signal(client, loglevel=loglevel)
except Exception:
logger.exception('Failed to install Celery error handler')
def configure_sentry(app):
from flask import session
from raven.contrib.celery import register_signal, register_logger_signal
sentry.init_app(app)
@app.before_request
def capture_user(*args, **kwargs):
if "uid" in session:
sentry.client.user_context({"id": session["uid"], "email": session["email"]})
register_signal(sentry.client)
register_logger_signal(sentry.client)
def flask_app(self):
if self._flask_app is None:
self.flask_app_factory = symbol_by_name(self.flask_app_factory)
app = self._flask_app = self.flask_app_factory()
self.app_context = app.app_context()
if 'sentry' in app.extensions:
from raven.contrib.celery import register_signal, register_logger_signal
client = app.extensions['sentry'].client
register_signal(client)
register_logger_signal(client)
return self._flask_app
def init_sentry(app):
sentry = IndicoSentry(wrap_wsgi=False, register_signal=True, logging=False)
sentry.init_app(app)
# setup logging manually and exclude uncaught indico exceptions.
# these are logged manually in the flask error handler logic so
# we get the X-Sentry-ID header which is not populated in the
# logging handlers
handler = SentryHandler(sentry.client, level=getattr(logging, config.SENTRY_LOGGING_LEVEL))
handler.addFilter(BlacklistFilter({'indico.flask', 'celery.redirected'}))
setup_logging(handler)
# connect to the celery logger
register_logger_signal(sentry.client)
register_signal(sentry.client)
def init_app(app):
if 'SENTRY_DSN' in app.config:
try:
from raven.contrib.celery import (
register_signal, register_logger_signal
)
from raven.contrib.flask import Sentry
except:
log.error('raven[flask] is required to use sentry')
return
sentry = Sentry()
tags = app.config['SENTRY_TAGS'] = app.config.get('SENTRY_TAGS', {})
app.config.setdefault('SENTRY_USER_ATTRS',
['slug', 'email', 'fullname'])
app.config.setdefault('SENTRY_LOGGING', 'WARNING')
log_level_name = app.config.get('SENTRY_LOGGING')
if log_level_name:
log_level = getattr(logging, log_level_name.upper())
if log_level:
sentry.logging = True
sentry.level = log_level
# Do not send HTTPExceptions
exceptions = app.config.get('RAVEN_IGNORE_EXCEPTIONS', [])
if HTTPException not in exceptions:
exceptions.append(HTTPException)
if PermissionDenied not in exceptions:
exceptions.append(PermissionDenied)
app.config['RAVEN_IGNORE_EXCEPTIONS'] = exceptions
app.config['SENTRY_PUBLIC_DSN'] = public_dsn(app.config['SENTRY_DSN'])
# Versions Management: uData and plugins versions as tags.
packages = ['udata']
packages += ['udata_{0}'.format(p) for p in app.config['PLUGINS']]
for package in packages:
version = pkg_resources.get_distribution(package).version
if version:
tags[package] = version
sentry.init_app(app)
# register a custom filter to filter out duplicate logs
register_logger_signal(sentry.client, loglevel=sentry.level)
# hook into the Celery error handler
register_signal(sentry.client)
