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 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_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 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 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 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 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 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 = 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 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):
        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):
        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_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):  # 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):
        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):
        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 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):
        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):
        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)