black: reformat source

backend/setup.py

@@ -4,12 +4,12 b' import re'
 from setuptools import setup, find_packages
 
 here = os.path.abspath(os.path.dirname(__file__))
-README = open(os.path.join(here, 'README.rst')).read()
-CHANGES = open(os.path.join(here, 'CHANGELOG.rst')).read()
+README = open(os.path.join(here, "README.rst")).read()
+CHANGES = open(os.path.join(here, "CHANGELOG.rst")).read()
 
-REQUIREMENTS = open(os.path.join(here, 'requirements.txt')).readlines()
+REQUIREMENTS = open(os.path.join(here, "requirements.txt")).readlines()
 
-compiled = re.compile('([^=><]*).*')
+compiled = re.compile("([^=><]*).*")
 
 
 def parse_req(req):
@@ -21,7 +21,8 b' requires = [_f for _f in map(parse_req, REQUIREMENTS) if _f]'
 
 def _get_meta_var(name, data, callback_handler=None):
     import re
-    matches = re.compile(r'(?:%s)\s*=\s*(.*)' % name).search(data)
+
+    matches = re.compile(r"(?:%s)\s*=\s*(.*)" % name).search(data)
     if matches:
         if not callable(callback_handler):
             callback_handler = lambda v: v
@@ -29,21 +30,22 b' def _get_meta_var(name, data, callback_handler=None):'
         return callback_handler(eval(matches.groups()[0]))
 
 
-with open(os.path.join(here, 'src', 'appenlight', '__init__.py'), 'r') as _meta:
+with open(os.path.join(here, "src", "appenlight", "__init__.py"), "r") as _meta:
     _metadata = _meta.read()
 
-with open(os.path.join(here, 'VERSION'), 'r') as _meta_version:
+with open(os.path.join(here, "VERSION"), "r") as _meta_version:
     __version__ = _meta_version.read().strip()
 
-__license__ = _get_meta_var('__license__', _metadata)
-__author__ = _get_meta_var('__author__', _metadata)
-__url__ = _get_meta_var('__url__', _metadata)
+__license__ = _get_meta_var("__license__", _metadata)
+__author__ = _get_meta_var("__author__", _metadata)
+__url__ = _get_meta_var("__url__", _metadata)
 
-found_packages = find_packages('src')
-found_packages.append('appenlight.migrations.versions')
-setup(name='appenlight',
-      description='appenlight',
-      long_description=README + '\n\n' + CHANGES,
+found_packages = find_packages("src")
+found_packages.append("appenlight.migrations.versions")
+setup(
+    name="appenlight",
+    description="appenlight",
+    long_description=README + "\n\n" + CHANGES,
       classifiers=[
           "Programming Language :: Python",
           "Framework :: Pylons",
@@ -54,28 +56,34 b" setup(name='appenlight',"
       license=__license__,
       author=__author__,
       url=__url__,
-      keywords='web wsgi bfg pylons pyramid',
-      package_dir={'': 'src'},
+    keywords="web wsgi bfg pylons pyramid",
+    package_dir={"": "src"},
       packages=found_packages,
       include_package_data=True,
       zip_safe=False,
-      test_suite='appenlight',
+    test_suite="appenlight",
       install_requires=requires,
       extras_require={
-          "dev": ["coverage", "pytest", "pyramid", "tox", "mock", "pytest-mock", "webtest"],
+        "dev": [
+            "coverage",
+            "pytest",
+            "pyramid",
+            "tox",
+            "mock",
+            "pytest-mock",
+            "webtest",
+        ],
           "lint": ["black"],
       },
       entry_points={
-          'paste.app_factory': [
-              'main = appenlight:main'
+        "paste.app_factory": ["main = appenlight:main"],
+        "console_scripts": [
+            "appenlight-cleanup = appenlight.scripts.cleanup:main",
+            "appenlight-initializedb = appenlight.scripts.initialize_db:main",
+            "appenlight-migratedb = appenlight.scripts.migratedb:main",
+            "appenlight-reindex-elasticsearch = appenlight.scripts.reindex_elasticsearch:main",
+            "appenlight-static = appenlight.scripts.static:main",
+            "appenlight-make-config = appenlight.scripts.make_config:main",
           ],
-          'console_scripts': [
-              'appenlight-cleanup = appenlight.scripts.cleanup:main',
-              'appenlight-initializedb = appenlight.scripts.initialize_db:main',
-              'appenlight-migratedb = appenlight.scripts.migratedb:main',
-              'appenlight-reindex-elasticsearch = appenlight.scripts.reindex_elasticsearch:main',
-              'appenlight-static = appenlight.scripts.static:main',
-              'appenlight-make-config = appenlight.scripts.make_config:main',
-          ]
-      }
+    },
       )

backend/src/appenlight/__init__.py

@@ -38,15 +38,17 b' from redlock import Redlock'
 from sqlalchemy import engine_from_config
 
 from appenlight.celery import configure_celery
-from appenlight.lib.configurator import (CythonCompatConfigurator,
-                                         register_appenlight_plugin)
+from appenlight.lib.configurator import (
+    CythonCompatConfigurator,
+    register_appenlight_plugin,
+)
 from appenlight.lib import cache_regions
 from appenlight.lib.ext_json import json
 from appenlight.security import groupfinder, AuthTokenAuthenticationPolicy
 
-__license__ = 'Apache 2.0'
-__author__ = 'RhodeCode GmbH'
-__url__ = 'http://rhodecode.com'
+__license__ = "Apache 2.0"
+__author__ = "RhodeCode GmbH"
+__url__ = "http://rhodecode.com"
 __version__ = pkg_resources.get_distribution("appenlight").parsed_version
 
 json_renderer = JSON(serializer=json.dumps, indent=4)
@@ -59,7 +61,7 b' def datetime_adapter(obj, request):'
 
 
 def all_permissions_adapter(obj, request):
-    return '__all_permissions__'
+    return "__all_permissions__"
 
 
 json_renderer.add_adapter(datetime.datetime, datetime_adapter)
@@ -70,91 +72,109 b' def main(global_config, **settings):'
     """ This function returns a Pyramid WSGI application.
     """
     auth_tkt_policy = AuthTktAuthenticationPolicy(
-        settings['authtkt.secret'],
-        hashalg='sha512',
+        settings["authtkt.secret"],
+        hashalg="sha512",
         callback=groupfinder,
         max_age=2592000,
-        secure=asbool(settings.get('authtkt.secure', 'false')))
-    auth_token_policy = AuthTokenAuthenticationPolicy(
-        callback=groupfinder
+        secure=asbool(settings.get("authtkt.secure", "false")),
     )
+    auth_token_policy = AuthTokenAuthenticationPolicy(callback=groupfinder)
     authorization_policy = ACLAuthorizationPolicy()
     authentication_policy = AuthenticationStackPolicy()
-    authentication_policy.add_policy('auth_tkt', auth_tkt_policy)
-    authentication_policy.add_policy('auth_token', auth_token_policy)
+    authentication_policy.add_policy("auth_tkt", auth_tkt_policy)
+    authentication_policy.add_policy("auth_token", auth_token_policy)
     # set crypto key
-    encryption.ENCRYPTION_SECRET = settings.get('encryption_secret')
+    encryption.ENCRYPTION_SECRET = settings.get("encryption_secret")
     # import this later so encyption key can be monkeypatched
     from appenlight.models import DBSession, register_datastores
 
     # registration
-    settings['appenlight.disable_registration'] = asbool(
-        settings.get('appenlight.disable_registration'))
+    settings["appenlight.disable_registration"] = asbool(
+        settings.get("appenlight.disable_registration")
+    )
 
     # update config with cometd info
-    settings['cometd_servers'] = {'server': settings['cometd.server'],
-                                  'secret': settings['cometd.secret']}
+    settings["cometd_servers"] = {
+        "server": settings["cometd.server"],
+        "secret": settings["cometd.secret"],
+    }
 
     # Create the Pyramid Configurator.
-    settings['_mail_url'] = settings['mailing.app_url']
+    settings["_mail_url"] = settings["mailing.app_url"]
     config = CythonCompatConfigurator(
         settings=settings,
         authentication_policy=authentication_policy,
         authorization_policy=authorization_policy,
-        root_factory='appenlight.security.RootFactory',
-        default_permission='view')
+        root_factory="appenlight.security.RootFactory",
+        default_permission="view",
+    )
     # custom registry variables
 
     # resource type information
-    config.registry.resource_types = ['resource', 'application']
+    config.registry.resource_types = ["resource", "application"]
     # plugin information
     config.registry.appenlight_plugins = {}
 
-    config.set_default_csrf_options(require_csrf=True, header='X-XSRF-TOKEN')
-    config.add_view_deriver('appenlight.predicates.csrf_view',
-                            name='csrf_view')
+    config.set_default_csrf_options(require_csrf=True, header="X-XSRF-TOKEN")
+    config.add_view_deriver("appenlight.predicates.csrf_view", name="csrf_view")
 
     # later, when config is available
-    dogpile_config = {'url': settings['redis.url'],
+    dogpile_config = {
+        "url": settings["redis.url"],
                       "redis_expiration_time": 86400,
-                      "redis_distributed_lock": True}
+        "redis_distributed_lock": True,
+    }
     cache_regions.regions = cache_regions.CacheRegions(dogpile_config)
     config.registry.cache_regions = cache_regions.regions
-    engine = engine_from_config(settings, 'sqlalchemy.',
-                                json_serializer=json.dumps)
+    engine = engine_from_config(settings, "sqlalchemy.", json_serializer=json.dumps)
     DBSession.configure(bind=engine)
 
     # json rederer that serializes datetime
-    config.add_renderer('json', json_renderer)
-    config.add_request_method('appenlight.lib.request.es_conn', 'es_conn', property=True)
-    config.add_request_method('appenlight.lib.request.get_user', 'user',
-                                reify=True, property=True)
-    config.add_request_method('appenlight.lib.request.get_csrf_token',
-                                'csrf_token', reify=True, property=True)
-    config.add_request_method('appenlight.lib.request.safe_json_body',
-                                'safe_json_body', reify=True, property=True)
-    config.add_request_method('appenlight.lib.request.unsafe_json_body',
-                                'unsafe_json_body', reify=True, property=True)
-    config.add_request_method('appenlight.lib.request.add_flash_to_headers',
-                              'add_flash_to_headers')
-    config.add_request_method('appenlight.lib.request.get_authomatic',
-                              'authomatic', reify=True)
-
-    config.include('pyramid_redis_sessions')
-    config.include('pyramid_tm')
-    config.include('pyramid_jinja2')
-    config.include('pyramid_mailer')
-    config.include('appenlight_client.ext.pyramid_tween')
-    config.include('ziggurat_foundations.ext.pyramid.sign_in')
-    es_server_list = aslist(settings['elasticsearch.nodes'])
-    redis_url = settings['redis.url']
-    log.warning('Elasticsearch server list: {}'.format(es_server_list))
-    log.warning('Redis server: {}'.format(redis_url))
+    config.add_renderer("json", json_renderer)
+    config.add_request_method(
+        "appenlight.lib.request.es_conn", "es_conn", property=True
+    )
+    config.add_request_method(
+        "appenlight.lib.request.get_user", "user", reify=True, property=True
+    )
+    config.add_request_method(
+        "appenlight.lib.request.get_csrf_token", "csrf_token", reify=True, property=True
+    )
+    config.add_request_method(
+        "appenlight.lib.request.safe_json_body",
+        "safe_json_body",
+        reify=True,
+        property=True,
+    )
+    config.add_request_method(
+        "appenlight.lib.request.unsafe_json_body",
+        "unsafe_json_body",
+        reify=True,
+        property=True,
+    )
+    config.add_request_method(
+        "appenlight.lib.request.add_flash_to_headers", "add_flash_to_headers"
+    )
+    config.add_request_method(
+        "appenlight.lib.request.get_authomatic", "authomatic", reify=True
+    )
+
+    config.include("pyramid_redis_sessions")
+    config.include("pyramid_tm")
+    config.include("pyramid_jinja2")
+    config.include("pyramid_mailer")
+    config.include("appenlight_client.ext.pyramid_tween")
+    config.include("ziggurat_foundations.ext.pyramid.sign_in")
+    es_server_list = aslist(settings["elasticsearch.nodes"])
+    redis_url = settings["redis.url"]
+    log.warning("Elasticsearch server list: {}".format(es_server_list))
+    log.warning("Redis server: {}".format(redis_url))
     config.registry.es_conn = Elasticsearch(es_server_list)
     config.registry.redis_conn = redis.StrictRedis.from_url(redis_url)
 
-    config.registry.redis_lockmgr = Redlock([settings['redis.redlock.url'], ],
-                                            retry_count=0, retry_delay=0)
+    config.registry.redis_lockmgr = Redlock(
+        [settings["redis.redlock.url"]], retry_count=0, retry_delay=0
+    )
     # mailer bw compat
     config.registry.mailer = config.registry.getUtility(IMailer)
 
@@ -163,47 +183,56 b' def main(global_config, **settings):'
     config.set_session_factory(session_factory)
 
     # Configure renderers and event subscribers
-    config.add_jinja2_extension('jinja2.ext.loopcontrols')
-    config.add_jinja2_search_path('appenlight:templates')
+    config.add_jinja2_extension("jinja2.ext.loopcontrols")
+    config.add_jinja2_search_path("appenlight:templates")
     # event subscribers
-    config.add_subscriber("appenlight.subscribers.application_created",
-                          "pyramid.events.ApplicationCreated")
-    config.add_subscriber("appenlight.subscribers.add_renderer_globals",
-                          "pyramid.events.BeforeRender")
-    config.add_subscriber('appenlight.subscribers.new_request',
-                          'pyramid.events.NewRequest')
-    config.add_view_predicate('context_type_class',
-                              'appenlight.predicates.contextTypeClass')
-
-    register_datastores(es_conn=config.registry.es_conn,
+    config.add_subscriber(
+        "appenlight.subscribers.application_created",
+        "pyramid.events.ApplicationCreated",
+    )
+    config.add_subscriber(
+        "appenlight.subscribers.add_renderer_globals", "pyramid.events.BeforeRender"
+    )
+    config.add_subscriber(
+        "appenlight.subscribers.new_request", "pyramid.events.NewRequest"
+    )
+    config.add_view_predicate(
+        "context_type_class", "appenlight.predicates.contextTypeClass"
+    )
+
+    register_datastores(
+        es_conn=config.registry.es_conn,
                         redis_conn=config.registry.redis_conn,
-                        redis_lockmgr=config.registry.redis_lockmgr)
+        redis_lockmgr=config.registry.redis_lockmgr,
+    )
 
     # base stuff and scan
 
     # need to ensure webassets exists otherwise config.override_asset()
     # throws exception
-    if not os.path.exists(settings['webassets.dir']):
-        os.mkdir(settings['webassets.dir'])
-    config.add_static_view(path='appenlight:webassets',
-                           name='static', cache_max_age=3600)
-    config.override_asset(to_override='appenlight:webassets/',
-                          override_with=settings['webassets.dir'])
-
-    config.include('appenlight.views')
-    config.include('appenlight.views.admin')
-    config.scan(ignore=['appenlight.migrations', 'appenlight.scripts',
-                        'appenlight.tests'])
-
-    config.add_directive('register_appenlight_plugin',
-                         register_appenlight_plugin)
-
-    for entry_point in iter_entry_points(group='appenlight.plugins'):
+    if not os.path.exists(settings["webassets.dir"]):
+        os.mkdir(settings["webassets.dir"])
+    config.add_static_view(
+        path="appenlight:webassets", name="static", cache_max_age=3600
+    )
+    config.override_asset(
+        to_override="appenlight:webassets/", override_with=settings["webassets.dir"]
+    )
+
+    config.include("appenlight.views")
+    config.include("appenlight.views.admin")
+    config.scan(
+        ignore=["appenlight.migrations", "appenlight.scripts", "appenlight.tests"]
+    )
+
+    config.add_directive("register_appenlight_plugin", register_appenlight_plugin)
+
+    for entry_point in iter_entry_points(group="appenlight.plugins"):
         plugin = entry_point.load()
         plugin.includeme(config)
 
     # include other appenlight plugins explictly if needed
-    includes = aslist(settings.get('appenlight.includes', []))
+    includes = aslist(settings.get("appenlight.includes", []))
     for inc in includes:
         config.include(inc)
 
@@ -211,8 +240,8 b' def main(global_config, **settings):'
 
     def pre_commit():
         jinja_env = config.get_jinja2_environment()
-        jinja_env.filters['tojson'] = json.dumps
-        jinja_env.filters['toJSONUnsafe'] = jinja2_filters.toJSONUnsafe
+        jinja_env.filters["tojson"] = json.dumps
+        jinja_env.filters["toJSONUnsafe"] = jinja2_filters.toJSONUnsafe
 
     config.action(None, pre_commit, order=PHASE3_CONFIG + 999)
 

backend/src/appenlight/celery/__init__.py

@@ -34,15 +34,23 b' from appenlight_client.ext.celery import register_signals'
 
 log = logging.getLogger(__name__)
 
-register('date_json', json_dumps, json_loads,
-         content_type='application/x-date_json',
-         content_encoding='utf-8')
+register(
+    "date_json",
+    json_dumps,
+    json_loads,
+    content_type="application/x-date_json",
+    content_encoding="utf-8",
+)
 
 celery = Celery()
 
-celery.user_options['preload'].add(
-    Option('--ini', dest='ini', default=None,
-           help='Specifies pyramid configuration file location.')
+celery.user_options["preload"].add(
+    Option(
+        "--ini",
+        dest="ini",
+        default=None,
+        help="Specifies pyramid configuration file location.",
+    )
 )
 
 
@@ -51,19 +59,21 b' def on_preload_parsed(options, **kwargs):'
     """
     This actually configures celery from pyramid config file
     """
-    celery.conf['INI_PYRAMID'] = options['ini']
+    celery.conf["INI_PYRAMID"] = options["ini"]
     import appenlight_client.client as e_client
-    ini_location = options['ini']
+
+    ini_location = options["ini"]
     if not ini_location:
-        raise Exception('You need to pass pyramid ini location using '
-                        '--ini=filename.ini argument to the worker')
+        raise Exception(
+            "You need to pass pyramid ini location using "
+            "--ini=filename.ini argument to the worker"
+        )
     env = bootstrap(ini_location[0])
-    api_key = env['request'].registry.settings['appenlight.api_key']
-    tr_config = env['request'].registry.settings.get(
-        'appenlight.transport_config')
-    CONFIG = e_client.get_config({'appenlight.api_key': api_key})
+    api_key = env["request"].registry.settings["appenlight.api_key"]
+    tr_config = env["request"].registry.settings.get("appenlight.transport_config")
+    CONFIG = e_client.get_config({"appenlight.api_key": api_key})
     if tr_config:
-        CONFIG['appenlight.transport_config'] = tr_config
+        CONFIG["appenlight.transport_config"] = tr_config
     APPENLIGHT_CLIENT = e_client.Client(CONFIG)
     # log.addHandler(APPENLIGHT_CLIENT.log_handler)
     register_signals(APPENLIGHT_CLIENT)
@@ -71,101 +81,101 b' def on_preload_parsed(options, **kwargs):'
 
 
 celery_config = {
-    'CELERY_IMPORTS': ["appenlight.celery.tasks", ],
-    'CELERYD_TASK_TIME_LIMIT': 60,
-    'CELERYD_MAX_TASKS_PER_CHILD': 1000,
-    'CELERY_IGNORE_RESULT': True,
-    'CELERY_ACCEPT_CONTENT': ['date_json'],
-    'CELERY_TASK_SERIALIZER': 'date_json',
-    'CELERY_RESULT_SERIALIZER': 'date_json',
-    'BROKER_URL': None,
-    'CELERYD_CONCURRENCY': None,
-    'CELERY_TIMEZONE': None,
-    'CELERYBEAT_SCHEDULE': {
-        'alerting_reports': {
-            'task': 'appenlight.celery.tasks.alerting_reports',
-            'schedule': timedelta(seconds=60)
+    "CELERY_IMPORTS": ["appenlight.celery.tasks"],
+    "CELERYD_TASK_TIME_LIMIT": 60,
+    "CELERYD_MAX_TASKS_PER_CHILD": 1000,
+    "CELERY_IGNORE_RESULT": True,
+    "CELERY_ACCEPT_CONTENT": ["date_json"],
+    "CELERY_TASK_SERIALIZER": "date_json",
+    "CELERY_RESULT_SERIALIZER": "date_json",
+    "BROKER_URL": None,
+    "CELERYD_CONCURRENCY": None,
+    "CELERY_TIMEZONE": None,
+    "CELERYBEAT_SCHEDULE": {
+        "alerting_reports": {
+            "task": "appenlight.celery.tasks.alerting_reports",
+            "schedule": timedelta(seconds=60),
+        },
+        "close_alerts": {
+            "task": "appenlight.celery.tasks.close_alerts",
+            "schedule": timedelta(seconds=60),
+        },
         },
-        'close_alerts': {
-            'task': 'appenlight.celery.tasks.close_alerts',
-            'schedule': timedelta(seconds=60)
-        }
-    }
 }
 celery.config_from_object(celery_config)
 
 
 def configure_celery(pyramid_registry):
     settings = pyramid_registry.settings
-    celery_config['BROKER_URL'] = settings['celery.broker_url']
-    celery_config['CELERYD_CONCURRENCY'] = settings['celery.concurrency']
-    celery_config['CELERY_TIMEZONE'] = settings['celery.timezone']
+    celery_config["BROKER_URL"] = settings["celery.broker_url"]
+    celery_config["CELERYD_CONCURRENCY"] = settings["celery.concurrency"]
+    celery_config["CELERY_TIMEZONE"] = settings["celery.timezone"]
 
-    notifications_seconds = int(settings.get('tasks.notifications_reports.interval', 60))
+    notifications_seconds = int(
+        settings.get("tasks.notifications_reports.interval", 60)
+    )
 
-    celery_config['CELERYBEAT_SCHEDULE']['notifications'] = {
-        'task': 'appenlight.celery.tasks.notifications_reports',
-        'schedule': timedelta(seconds=notifications_seconds)
+    celery_config["CELERYBEAT_SCHEDULE"]["notifications"] = {
+        "task": "appenlight.celery.tasks.notifications_reports",
+        "schedule": timedelta(seconds=notifications_seconds),
     }
 
-    celery_config['CELERYBEAT_SCHEDULE']['daily_digest'] = {
-        'task': 'appenlight.celery.tasks.daily_digest',
-        'schedule': crontab(minute=1, hour='4,12,20')
+    celery_config["CELERYBEAT_SCHEDULE"]["daily_digest"] = {
+        "task": "appenlight.celery.tasks.daily_digest",
+        "schedule": crontab(minute=1, hour="4,12,20"),
     }
 
-    if asbool(settings.get('celery.always_eager')):
-        celery_config['CELERY_ALWAYS_EAGER'] = True
-        celery_config['CELERY_EAGER_PROPAGATES_EXCEPTIONS'] = True
+    if asbool(settings.get("celery.always_eager")):
+        celery_config["CELERY_ALWAYS_EAGER"] = True
+        celery_config["CELERY_EAGER_PROPAGATES_EXCEPTIONS"] = True
 
     for plugin in pyramid_registry.appenlight_plugins.values():
-        if plugin.get('celery_tasks'):
-            celery_config['CELERY_IMPORTS'].extend(plugin['celery_tasks'])
-        if plugin.get('celery_beats'):
-            for name, config in plugin['celery_beats']:
-                celery_config['CELERYBEAT_SCHEDULE'][name] = config
+        if plugin.get("celery_tasks"):
+            celery_config["CELERY_IMPORTS"].extend(plugin["celery_tasks"])
+        if plugin.get("celery_beats"):
+            for name, config in plugin["celery_beats"]:
+                celery_config["CELERYBEAT_SCHEDULE"][name] = config
     celery.config_from_object(celery_config)
 
 
 @task_prerun.connect
 def task_prerun_signal(task_id, task, args, kwargs, **kwaargs):
-    if hasattr(celery, 'pyramid'):
+    if hasattr(celery, "pyramid"):
         env = celery.pyramid
-        env = prepare(registry=env['request'].registry)
-        proper_base_url = env['request'].registry.settings['mailing.app_url']
-        tmp_req = Request.blank('/', base_url=proper_base_url)
+        env = prepare(registry=env["request"].registry)
+        proper_base_url = env["request"].registry.settings["mailing.app_url"]
+        tmp_req = Request.blank("/", base_url=proper_base_url)
         # ensure tasks generate url for right domain from config
-        env['request'].environ['HTTP_HOST'] = tmp_req.environ['HTTP_HOST']
-        env['request'].environ['SERVER_PORT'] = tmp_req.environ['SERVER_PORT']
-        env['request'].environ['SERVER_NAME'] = tmp_req.environ['SERVER_NAME']
-        env['request'].environ['wsgi.url_scheme'] = \
-            tmp_req.environ['wsgi.url_scheme']
+        env["request"].environ["HTTP_HOST"] = tmp_req.environ["HTTP_HOST"]
+        env["request"].environ["SERVER_PORT"] = tmp_req.environ["SERVER_PORT"]
+        env["request"].environ["SERVER_NAME"] = tmp_req.environ["SERVER_NAME"]
+        env["request"].environ["wsgi.url_scheme"] = tmp_req.environ["wsgi.url_scheme"]
     get_current_request().tm.begin()
 
 
 @task_success.connect
 def task_success_signal(result, **kwargs):
     get_current_request().tm.commit()
-    if hasattr(celery, 'pyramid'):
+    if hasattr(celery, "pyramid"):
         celery.pyramid["closer"]()
 
 
 @task_retry.connect
 def task_retry_signal(request, reason, einfo, **kwargs):
     get_current_request().tm.abort()
-    if hasattr(celery, 'pyramid'):
+    if hasattr(celery, "pyramid"):
         celery.pyramid["closer"]()
 
 
 @task_failure.connect
-def task_failure_signal(task_id, exception, args, kwargs, traceback, einfo,
-                        **kwaargs):
+def task_failure_signal(task_id, exception, args, kwargs, traceback, einfo, **kwaargs):
     get_current_request().tm.abort()
-    if hasattr(celery, 'pyramid'):
+    if hasattr(celery, "pyramid"):
         celery.pyramid["closer"]()
 
 
 @task_revoked.connect
 def task_revoked_signal(request, terminated, signum, expired, **kwaargs):
     get_current_request().tm.abort()
-    if hasattr(celery, 'pyramid'):
+    if hasattr(celery, "pyramid"):
         celery.pyramid["closer"]()

backend/src/appenlight/celery/encoders.py

@@ -17,38 +17,29 b''
 import json
 from datetime import datetime, date, timedelta
 
-DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.%f'
+DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%f"
 
 
 class DateEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, datetime):
-            return {
-                '__type__': '__datetime__',
-                'iso': obj.strftime(DATE_FORMAT)
-            }
+            return {"__type__": "__datetime__", "iso": obj.strftime(DATE_FORMAT)}
         elif isinstance(obj, date):
-            return {
-                '__type__': '__date__',
-                'iso': obj.strftime(DATE_FORMAT)
-            }
+            return {"__type__": "__date__", "iso": obj.strftime(DATE_FORMAT)}
         elif isinstance(obj, timedelta):
-            return {
-                '__type__': '__timedelta__',
-                'seconds': obj.total_seconds()
-            }
+            return {"__type__": "__timedelta__", "seconds": obj.total_seconds()}
         else:
             return json.JSONEncoder.default(self, obj)
 
 
 def date_decoder(dct):
-    if '__type__' in dct:
-        if dct['__type__'] == '__datetime__':
-            return datetime.strptime(dct['iso'], DATE_FORMAT)
-        elif dct['__type__'] == '__date__':
-            return datetime.strptime(dct['iso'], DATE_FORMAT).date()
-        elif dct['__type__'] == '__timedelta__':
-            return timedelta(seconds=dct['seconds'])
+    if "__type__" in dct:
+        if dct["__type__"] == "__datetime__":
+            return datetime.strptime(dct["iso"], DATE_FORMAT)
+        elif dct["__type__"] == "__date__":
+            return datetime.strptime(dct["iso"], DATE_FORMAT).date()
+        elif dct["__type__"] == "__timedelta__":
+            return timedelta(seconds=dct["seconds"])
     return dct
 
 
@@ -57,4 +48,4 b' def json_dumps(obj):'
 
 
 def json_loads(obj):
-    return json.loads(obj.decode('utf8'), object_hook=date_decoder)
+    return json.loads(obj.decode("utf8"), object_hook=date_decoder)

backend/src/appenlight/celery/tasks.py

@@ -51,9 +51,11 b' from appenlight.lib.enums import ReportType'
 
 log = get_task_logger(__name__)
 
-sample_boundries = list(range(100, 1000, 100)) + \
-                   list(range(1000, 10000, 1000)) + \
-                   list(range(10000, 100000, 5000))
+sample_boundries = (
+    list(range(100, 1000, 100))
+    + list(range(1000, 10000, 1000))
+    + list(range(10000, 100000, 5000))
+)
 
 
 def pick_sample(total_occurences, report_type=None):
@@ -70,9 +72,9 b' def pick_sample(total_occurences, report_type=None):'
 
 @celery.task(queue="default", default_retry_delay=1, max_retries=2)
 def test_exception_task():
-    log.error('test celery log', extra={'location': 'celery'})
-    log.warning('test celery log', extra={'location': 'celery'})
-    raise Exception('Celery exception test')
+    log.error("test celery log", extra={"location": "celery"})
+    log.warning("test celery log", extra={"location": "celery"})
+    raise Exception("Celery exception test")
 
 
 @celery.task(queue="default", default_retry_delay=1, max_retries=2)
@@ -81,9 +83,9 b' def test_retry_exception_task():'
         import time
 
         time.sleep(1.3)
-        log.error('test retry celery log', extra={'location': 'celery'})
-        log.warning('test retry celery log', extra={'location': 'celery'})
-        raise Exception('Celery exception test')
+        log.error("test retry celery log", extra={"location": "celery"})
+        log.warning("test retry celery log", extra={"location": "celery"})
+        raise Exception("Celery exception test")
     except Exception as exc:
         if celery.conf["CELERY_EAGER_PROPAGATES_EXCEPTIONS"]:
             raise
@@ -92,7 +94,7 b' def test_retry_exception_task():'
 
 @celery.task(queue="reports", default_retry_delay=600, max_retries=144)
 def add_reports(resource_id, request_params, dataset, **kwargs):
-    proto_version = parse_proto(request_params.get('protocol_version', ''))
+    proto_version = parse_proto(request_params.get("protocol_version", ""))
     current_time = datetime.utcnow().replace(second=0, microsecond=0)
     try:
         # we will store solr docs here for single insert
@@ -114,22 +116,26 b' def add_reports(resource_id, request_params, dataset, **kwargs):'
             report_group = ReportGroupService.by_hash_and_resource(
                 report.resource_id,
                 report.grouping_hash,
-                since_when=datetime.utcnow().date().replace(day=1)
+                since_when=datetime.utcnow().date().replace(day=1),
             )
-            occurences = report_data.get('occurences', 1)
+            occurences = report_data.get("occurences", 1)
             if not report_group:
                 # total reports will be +1 moment later
-                report_group = ReportGroup(grouping_hash=report.grouping_hash,
-                                           occurences=0, total_reports=0,
+                report_group = ReportGroup(
+                    grouping_hash=report.grouping_hash,
+                    occurences=0,
+                    total_reports=0,
                                            last_report=0,
                                            priority=report.priority,
                                            error=report.error,
-                                           first_timestamp=report.start_time)
+                    first_timestamp=report.start_time,
+                )
                 report_group._skip_ft_index = True
                 report_group.report_type = report.report_type
             report.report_group_time = report_group.first_timestamp
-            add_sample = pick_sample(report_group.occurences,
-                                     report_type=report_group.report_type)
+            add_sample = pick_sample(
+                report_group.occurences, report_type=report_group.report_type
+            )
             if add_sample:
                 resource.report_groups.append(report_group)
                 report_group.reports.append(report)
@@ -144,28 +150,26 b' def add_reports(resource_id, request_params, dataset, **kwargs):'
                 for s_call in slow_calls:
                     if s_call.partition_id not in es_slow_calls_docs:
                         es_slow_calls_docs[s_call.partition_id] = []
-                    es_slow_calls_docs[s_call.partition_id].append(
-                        s_call.es_doc())
+                    es_slow_calls_docs[s_call.partition_id].append(s_call.es_doc())
                     # try generating new stat rows if needed
             else:
                 # required for postprocessing to not fail later
                 report.report_group = report_group
 
-            stat_row = ReportService.generate_stat_rows(
-                report, resource, report_group)
+            stat_row = ReportService.generate_stat_rows(report, resource, report_group)
             if stat_row.partition_id not in es_reports_stats_rows:
                 es_reports_stats_rows[stat_row.partition_id] = []
-            es_reports_stats_rows[stat_row.partition_id].append(
-                stat_row.es_doc())
+            es_reports_stats_rows[stat_row.partition_id].append(stat_row.es_doc())
 
             # see if we should mark 10th occurence of report
             last_occurences_10 = int(math.floor(report_group.occurences / 10))
-            curr_occurences_10 = int(math.floor(
-                (report_group.occurences + report.occurences) / 10))
-            last_occurences_100 = int(
-                math.floor(report_group.occurences / 100))
-            curr_occurences_100 = int(math.floor(
-                (report_group.occurences + report.occurences) / 100))
+            curr_occurences_10 = int(
+                math.floor((report_group.occurences + report.occurences) / 10)
+            )
+            last_occurences_100 = int(math.floor(report_group.occurences / 100))
+            curr_occurences_100 = int(
+                math.floor((report_group.occurences + report.occurences) / 100)
+            )
             notify_occurences_10 = last_occurences_10 != curr_occurences_10
             notify_occurences_100 = last_occurences_100 != curr_occurences_100
             report_group.occurences = ReportGroup.occurences + occurences
@@ -178,39 +182,47 b' def add_reports(resource_id, request_params, dataset, **kwargs):'
             if added_details:
                 report_group.total_reports = ReportGroup.total_reports + 1
                 report_group.last_report = report.id
-            report_group.set_notification_info(notify_10=notify_occurences_10,
-                                               notify_100=notify_occurences_100)
+            report_group.set_notification_info(
+                notify_10=notify_occurences_10, notify_100=notify_occurences_100
+            )
             DBSession.flush()
             report_group.get_report().notify_channel(report_group)
             if report_group.partition_id not in es_report_group_docs:
                 es_report_group_docs[report_group.partition_id] = []
             es_report_group_docs[report_group.partition_id].append(
-                report_group.es_doc())
+                report_group.es_doc()
+            )
 
-            action = 'REPORT'
-            log_msg = '%s: %s %s, client: %s, proto: %s' % (
+            action = "REPORT"
+            log_msg = "%s: %s %s, client: %s, proto: %s" % (
                 action,
-                report_data.get('http_status', 'unknown'),
+                report_data.get("http_status", "unknown"),
                 str(resource),
-                report_data.get('client'),
-                proto_version)
+                report_data.get("client"),
+                proto_version,
+            )
             log.info(log_msg)
         total_reports = len(dataset)
         redis_pipeline = Datastores.redis.pipeline(transaction=False)
-        key = REDIS_KEYS['counters']['reports_per_minute'].format(current_time)
+        key = REDIS_KEYS["counters"]["reports_per_minute"].format(current_time)
         redis_pipeline.incr(key, total_reports)
         redis_pipeline.expire(key, 3600 * 24)
-        key = REDIS_KEYS['counters']['events_per_minute_per_user'].format(
-            resource.owner_user_id, current_time)
+        key = REDIS_KEYS["counters"]["events_per_minute_per_user"].format(
+            resource.owner_user_id, current_time
+        )
         redis_pipeline.incr(key, total_reports)
         redis_pipeline.expire(key, 3600)
-        key = REDIS_KEYS['counters']['reports_per_hour_per_app'].format(
-            resource_id, current_time.replace(minute=0))
+        key = REDIS_KEYS["counters"]["reports_per_hour_per_app"].format(
+            resource_id, current_time.replace(minute=0)
+        )
         redis_pipeline.incr(key, total_reports)
         redis_pipeline.expire(key, 3600 * 24 * 7)
         redis_pipeline.sadd(
-            REDIS_KEYS['apps_that_got_new_data_per_hour'].format(
-                current_time.replace(minute=0)), resource_id)
+            REDIS_KEYS["apps_that_got_new_data_per_hour"].format(
+                current_time.replace(minute=0)
+            ),
+            resource_id,
+        )
         redis_pipeline.execute()
 
         add_reports_es(es_report_group_docs, es_report_docs)
@@ -227,11 +239,11 b' def add_reports(resource_id, request_params, dataset, **kwargs):'
 @celery.task(queue="es", default_retry_delay=600, max_retries=144)
 def add_reports_es(report_group_docs, report_docs):
     for k, v in report_group_docs.items():
-        to_update = {'_index': k, '_type': 'report_group'}
+        to_update = {"_index": k, "_type": "report_group"}
         [i.update(to_update) for i in v]
         elasticsearch.helpers.bulk(Datastores.es, v)
     for k, v in report_docs.items():
-        to_update = {'_index': k, '_type': 'report'}
+        to_update = {"_index": k, "_type": "report"}
         [i.update(to_update) for i in v]
         elasticsearch.helpers.bulk(Datastores.es, v)
 
@@ -239,7 +251,7 b' def add_reports_es(report_group_docs, report_docs):'
 @celery.task(queue="es", default_retry_delay=600, max_retries=144)
 def add_reports_slow_calls_es(es_docs):
     for k, v in es_docs.items():
-        to_update = {'_index': k, '_type': 'log'}
+        to_update = {"_index": k, "_type": "log"}
         [i.update(to_update) for i in v]
         elasticsearch.helpers.bulk(Datastores.es, v)
 
@@ -247,14 +259,14 b' def add_reports_slow_calls_es(es_docs):'
 @celery.task(queue="es", default_retry_delay=600, max_retries=144)
 def add_reports_stats_rows_es(es_docs):
     for k, v in es_docs.items():
-        to_update = {'_index': k, '_type': 'log'}
+        to_update = {"_index": k, "_type": "log"}
         [i.update(to_update) for i in v]
         elasticsearch.helpers.bulk(Datastores.es, v)
 
 
 @celery.task(queue="logs", default_retry_delay=600, max_retries=144)
 def add_logs(resource_id, request_params, dataset, **kwargs):
-    proto_version = request_params.get('protocol_version')
+    proto_version = request_params.get("protocol_version")
     current_time = datetime.utcnow().replace(second=0, microsecond=0)
 
     try:
@@ -264,16 +276,15 b' def add_logs(resource_id, request_params, dataset, **kwargs):'
         ns_pairs = []
         for entry in dataset:
             # gather pk and ns so we can remove older versions of row later
-            if entry['primary_key'] is not None:
-                ns_pairs.append({"pk": entry['primary_key'],
-                                 "ns": entry['namespace']})
+            if entry["primary_key"] is not None:
+                ns_pairs.append({"pk": entry["primary_key"], "ns": entry["namespace"]})
             log_entry = Log()
             log_entry.set_data(entry, resource=resource)
             log_entry._skip_ft_index = True
             resource.logs.append(log_entry)
             DBSession.flush()
             # insert non pk rows first
-            if entry['primary_key'] is None:
+            if entry["primary_key"] is None:
                 es_docs[log_entry.partition_id].append(log_entry.es_doc())
 
         # 2nd pass to delete all log entries from db foe same pk/ns pair
@@ -282,7 +293,8 b' def add_logs(resource_id, request_params, dataset, **kwargs):'
             es_docs = collections.defaultdict(list)
             es_docs_to_delete = collections.defaultdict(list)
             found_pkey_logs = LogService.query_by_primary_key_and_namespace(
-                list_of_pairs=ns_pairs)
+                list_of_pairs=ns_pairs
+            )
             log_dict = {}
             for log_entry in found_pkey_logs:
                 log_key = (log_entry.primary_key, log_entry.namespace)
@@ -299,51 +311,58 b' def add_logs(resource_id, request_params, dataset, **kwargs):'
                     ids_to_delete.append(e.log_id)
                     es_docs_to_delete[e.partition_id].append(e.delete_hash)
 
-                es_docs_to_delete[log_entry.partition_id].append(
-                    log_entry.delete_hash)
+                es_docs_to_delete[log_entry.partition_id].append(log_entry.delete_hash)
 
                 es_docs[log_entry.partition_id].append(log_entry.es_doc())
 
             if ids_to_delete:
-                query = DBSession.query(Log).filter(
-                    Log.log_id.in_(ids_to_delete))
+                query = DBSession.query(Log).filter(Log.log_id.in_(ids_to_delete))
                 query.delete(synchronize_session=False)
             if es_docs_to_delete:
                 # batch this to avoid problems with default ES bulk limits
                 for es_index in es_docs_to_delete.keys():
                     for batch in in_batches(es_docs_to_delete[es_index], 20):
-                        query = {"query": {'terms': {'delete_hash': batch}}}
+                        query = {"query": {"terms": {"delete_hash": batch}}}
 
                         try:
                             Datastores.es.transport.perform_request(
-                                "DELETE", '/{}/{}/_query'.format(es_index, 'log'), body=query)
+                                "DELETE",
+                                "/{}/{}/_query".format(es_index, "log"),
+                                body=query,
+                            )
                         except elasticsearch.exceptions.NotFoundError as exc:
-                            msg = 'skipping index {}'.format(es_index)
+                            msg = "skipping index {}".format(es_index)
                             log.info(msg)
 
         total_logs = len(dataset)
 
-        log_msg = 'LOG_NEW: %s, entries: %s, proto:%s' % (
+        log_msg = "LOG_NEW: %s, entries: %s, proto:%s" % (
             str(resource),
             total_logs,
-            proto_version)
+            proto_version,
+        )
         log.info(log_msg)
         # mark_changed(session)
         redis_pipeline = Datastores.redis.pipeline(transaction=False)
-        key = REDIS_KEYS['counters']['logs_per_minute'].format(current_time)
+        key = REDIS_KEYS["counters"]["logs_per_minute"].format(current_time)
         redis_pipeline.incr(key, total_logs)
         redis_pipeline.expire(key, 3600 * 24)
-        key = REDIS_KEYS['counters']['events_per_minute_per_user'].format(
-            resource.owner_user_id, current_time)
+        key = REDIS_KEYS["counters"]["events_per_minute_per_user"].format(
+            resource.owner_user_id, current_time
+        )
         redis_pipeline.incr(key, total_logs)
         redis_pipeline.expire(key, 3600)
-        key = REDIS_KEYS['counters']['logs_per_hour_per_app'].format(
-            resource_id, current_time.replace(minute=0))
+        key = REDIS_KEYS["counters"]["logs_per_hour_per_app"].format(
+            resource_id, current_time.replace(minute=0)
+        )
         redis_pipeline.incr(key, total_logs)
         redis_pipeline.expire(key, 3600 * 24 * 7)
         redis_pipeline.sadd(
-            REDIS_KEYS['apps_that_got_new_data_per_hour'].format(
-                current_time.replace(minute=0)), resource_id)
+            REDIS_KEYS["apps_that_got_new_data_per_hour"].format(
+                current_time.replace(minute=0)
+            ),
+            resource_id,
+        )
         redis_pipeline.execute()
         add_logs_es(es_docs)
         return True
@@ -357,7 +376,7 b' def add_logs(resource_id, request_params, dataset, **kwargs):'
 @celery.task(queue="es", default_retry_delay=600, max_retries=144)
 def add_logs_es(es_docs):
     for k, v in es_docs.items():
-        to_update = {'_index': k, '_type': 'log'}
+        to_update = {"_index": k, "_type": "log"}
         [i.update(to_update) for i in v]
         elasticsearch.helpers.bulk(Datastores.es, v)
 
@@ -371,45 +390,51 b' def add_metrics(resource_id, request_params, dataset, proto_version):'
         es_docs = []
         rows = []
         for metric in dataset:
-            tags = dict(metric['tags'])
-            server_n = tags.get('server_name', metric['server_name']).lower()
-            tags['server_name'] = server_n or 'unknown'
+            tags = dict(metric["tags"])
+            server_n = tags.get("server_name", metric["server_name"]).lower()
+            tags["server_name"] = server_n or "unknown"
             new_metric = Metric(
-                timestamp=metric['timestamp'],
+                timestamp=metric["timestamp"],
                 resource_id=resource.resource_id,
-                namespace=metric['namespace'],
-                tags=tags)
+                namespace=metric["namespace"],
+                tags=tags,
+            )
             rows.append(new_metric)
             es_docs.append(new_metric.es_doc())
         session = DBSession()
         session.bulk_save_objects(rows)
         session.flush()
 
-        action = 'METRICS'
-        metrics_msg = '%s: %s, metrics: %s, proto:%s' % (
+        action = "METRICS"
+        metrics_msg = "%s: %s, metrics: %s, proto:%s" % (
             action,
             str(resource),
             len(dataset),
-            proto_version
+            proto_version,
         )
         log.info(metrics_msg)
 
         mark_changed(session)
         redis_pipeline = Datastores.redis.pipeline(transaction=False)
-        key = REDIS_KEYS['counters']['metrics_per_minute'].format(current_time)
+        key = REDIS_KEYS["counters"]["metrics_per_minute"].format(current_time)
         redis_pipeline.incr(key, len(rows))
         redis_pipeline.expire(key, 3600 * 24)
-        key = REDIS_KEYS['counters']['events_per_minute_per_user'].format(
-            resource.owner_user_id, current_time)
+        key = REDIS_KEYS["counters"]["events_per_minute_per_user"].format(
+            resource.owner_user_id, current_time
+        )
         redis_pipeline.incr(key, len(rows))
         redis_pipeline.expire(key, 3600)
-        key = REDIS_KEYS['counters']['metrics_per_hour_per_app'].format(
-            resource_id, current_time.replace(minute=0))
+        key = REDIS_KEYS["counters"]["metrics_per_hour_per_app"].format(
+            resource_id, current_time.replace(minute=0)
+        )
         redis_pipeline.incr(key, len(rows))
         redis_pipeline.expire(key, 3600 * 24 * 7)
         redis_pipeline.sadd(
-            REDIS_KEYS['apps_that_got_new_data_per_hour'].format(
-                current_time.replace(minute=0)), resource_id)
+            REDIS_KEYS["apps_that_got_new_data_per_hour"].format(
+                current_time.replace(minute=0)
+            ),
+            resource_id,
+        )
         redis_pipeline.execute()
         add_metrics_es(es_docs)
         return True
@@ -423,8 +448,8 b' def add_metrics(resource_id, request_params, dataset, proto_version):'
 @celery.task(queue="es", default_retry_delay=600, max_retries=144)
 def add_metrics_es(es_docs):
     for doc in es_docs:
-        partition = 'rcae_m_%s' % doc['timestamp'].strftime('%Y_%m_%d')
-        Datastores.es.index(partition, 'log', doc)
+        partition = "rcae_m_%s" % doc["timestamp"].strftime("%Y_%m_%d")
+        Datastores.es.index(partition, "log", doc)
 
 
 @celery.task(queue="default", default_retry_delay=5, max_retries=2)
@@ -435,10 +460,12 b' def check_user_report_notifications(resource_id):'
         application = ApplicationService.by_id(resource_id)
         if not application:
             return
-        error_key = REDIS_KEYS['reports_to_notify_per_type_per_app'].format(
-            ReportType.error, resource_id)
-        slow_key = REDIS_KEYS['reports_to_notify_per_type_per_app'].format(
-            ReportType.slow, resource_id)
+        error_key = REDIS_KEYS["reports_to_notify_per_type_per_app"].format(
+            ReportType.error, resource_id
+        )
+        slow_key = REDIS_KEYS["reports_to_notify_per_type_per_app"].format(
+            ReportType.slow, resource_id
+        )
         error_group_ids = Datastores.redis.smembers(error_key)
         slow_group_ids = Datastores.redis.smembers(slow_key)
         Datastores.redis.delete(error_key)
@@ -448,8 +475,7 b' def check_user_report_notifications(resource_id):'
         group_ids = err_gids + slow_gids
         occurence_dict = {}
         for g_id in group_ids:
-            key = REDIS_KEYS['counters']['report_group_occurences'].format(
-                g_id)
+            key = REDIS_KEYS["counters"]["report_group_occurences"].format(g_id)
             val = Datastores.redis.get(key)
             Datastores.redis.delete(key)
             if val:
@@ -460,14 +486,23 b' def check_user_report_notifications(resource_id):'
         report_groups.options(sa.orm.joinedload(ReportGroup.last_report_ref))
 
         ApplicationService.check_for_groups_alert(
-            application, 'alert', report_groups=report_groups,
-            occurence_dict=occurence_dict)
-        users = set([p.user for p in ResourceService.users_for_perm(application, 'view')])
+            application,
+            "alert",
+            report_groups=report_groups,
+            occurence_dict=occurence_dict,
+        )
+        users = set(
+            [p.user for p in ResourceService.users_for_perm(application, "view")]
+        )
         report_groups = report_groups.all()
         for user in users:
-            UserService.report_notify(user, request, application,
+            UserService.report_notify(
+                user,
+                request,
+                application,
                                       report_groups=report_groups,
-                                      occurence_dict=occurence_dict)
+                occurence_dict=occurence_dict,
+            )
         for group in report_groups:
             # marks report_groups as notified
             if not group.notified:
@@ -485,12 +520,12 b' def check_alerts(resource_id):'
         application = ApplicationService.by_id(resource_id)
         if not application:
             return
-        error_key = REDIS_KEYS[
-            'reports_to_notify_per_type_per_app_alerting'].format(
-            ReportType.error, resource_id)
-        slow_key = REDIS_KEYS[
-            'reports_to_notify_per_type_per_app_alerting'].format(
-            ReportType.slow, resource_id)
+        error_key = REDIS_KEYS["reports_to_notify_per_type_per_app_alerting"].format(
+            ReportType.error, resource_id
+        )
+        slow_key = REDIS_KEYS["reports_to_notify_per_type_per_app_alerting"].format(
+            ReportType.slow, resource_id
+        )
         error_group_ids = Datastores.redis.smembers(error_key)
         slow_group_ids = Datastores.redis.smembers(slow_key)
         Datastores.redis.delete(error_key)
@@ -500,9 +535,9 b' def check_alerts(resource_id):'
         group_ids = err_gids + slow_gids
         occurence_dict = {}
         for g_id in group_ids:
-            key = REDIS_KEYS['counters'][
-                'report_group_occurences_alerting'].format(
-                g_id)
+            key = REDIS_KEYS["counters"]["report_group_occurences_alerting"].format(
+                g_id
+            )
             val = Datastores.redis.get(key)
             Datastores.redis.delete(key)
             if val:
@@ -513,8 +548,12 b' def check_alerts(resource_id):'
         report_groups.options(sa.orm.joinedload(ReportGroup.last_report_ref))
 
         ApplicationService.check_for_groups_alert(
-            application, 'alert', report_groups=report_groups,
-            occurence_dict=occurence_dict, since_when=since_when)
+            application,
+            "alert",
+            report_groups=report_groups,
+            occurence_dict=occurence_dict,
+            since_when=since_when,
+        )
     except Exception as exc:
         print_traceback(log)
         raise
@@ -522,21 +561,21 b' def check_alerts(resource_id):'
 
 @celery.task(queue="default", default_retry_delay=1, max_retries=2)
 def close_alerts():
-    log.warning('Checking alerts')
+    log.warning("Checking alerts")
     since_when = datetime.utcnow()
     try:
-        event_types = [Event.types['error_report_alert'],
-                       Event.types['slow_report_alert'], ]
-        statuses = [Event.statuses['active']]
+        event_types = [
+            Event.types["error_report_alert"],
+            Event.types["slow_report_alert"],
+        ]
+        statuses = [Event.statuses["active"]]
         # get events older than 5 min
         events = EventService.by_type_and_status(
-            event_types,
-            statuses,
-            older_than=(since_when - timedelta(minutes=5)))
+            event_types, statuses, older_than=(since_when - timedelta(minutes=5))
+        )
         for event in events:
             # see if we can close them
-            event.validate_or_close(
-                since_when=(since_when - timedelta(minutes=1)))
+            event.validate_or_close(since_when=(since_when - timedelta(minutes=1)))
     except Exception as exc:
         print_traceback(log)
         raise
@@ -545,12 +584,18 b' def close_alerts():'
 @celery.task(queue="default", default_retry_delay=600, max_retries=144)
 def update_tag_counter(tag_name, tag_value, count):
     try:
-        query = DBSession.query(Tag).filter(Tag.name == tag_name).filter(
-            sa.cast(Tag.value, sa.types.TEXT) == sa.cast(json.dumps(tag_value),
-                                                         sa.types.TEXT))
-        query.update({'times_seen': Tag.times_seen + count,
-                      'last_timestamp': datetime.utcnow()},
-                     synchronize_session=False)
+        query = (
+            DBSession.query(Tag)
+            .filter(Tag.name == tag_name)
+            .filter(
+                sa.cast(Tag.value, sa.types.TEXT)
+                == sa.cast(json.dumps(tag_value), sa.types.TEXT)
+            )
+        )
+        query.update(
+            {"times_seen": Tag.times_seen + count, "last_timestamp": datetime.utcnow()},
+            synchronize_session=False,
+        )
         session = DBSession()
         mark_changed(session)
         return True
@@ -566,8 +611,8 b' def update_tag_counters():'
     """
     Sets task to update counters for application tags
     """
-    tags = Datastores.redis.lrange(REDIS_KEYS['seen_tag_list'], 0, -1)
-    Datastores.redis.delete(REDIS_KEYS['seen_tag_list'])
+    tags = Datastores.redis.lrange(REDIS_KEYS["seen_tag_list"], 0, -1)
+    Datastores.redis.delete(REDIS_KEYS["seen_tag_list"])
     c = collections.Counter(tags)
     for t_json, count in c.items():
         tag_info = json.loads(t_json)
@@ -580,28 +625,34 b' def daily_digest():'
     Sends daily digest with top 50 error reports
     """
     request = get_current_request()
-    apps = Datastores.redis.smembers(REDIS_KEYS['apps_that_had_reports'])
-    Datastores.redis.delete(REDIS_KEYS['apps_that_had_reports'])
+    apps = Datastores.redis.smembers(REDIS_KEYS["apps_that_had_reports"])
+    Datastores.redis.delete(REDIS_KEYS["apps_that_had_reports"])
     since_when = datetime.utcnow() - timedelta(hours=8)
-    log.warning('Generating daily digests')
+    log.warning("Generating daily digests")
     for resource_id in apps:
-        resource_id = resource_id.decode('utf8')
+        resource_id = resource_id.decode("utf8")
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
-        filter_settings = {'resource': [resource_id],
-                           'tags': [{'name': 'type',
-                                     'value': ['error'], 'op': None}],
-                           'type': 'error', 'start_date': since_when,
-                           'end_date': end_date}
+        filter_settings = {
+            "resource": [resource_id],
+            "tags": [{"name": "type", "value": ["error"], "op": None}],
+            "type": "error",
+            "start_date": since_when,
+            "end_date": end_date,
+        }
 
         reports = ReportGroupService.get_trending(
-            request, filter_settings=filter_settings, limit=50)
+            request, filter_settings=filter_settings, limit=50
+        )
 
         application = ApplicationService.by_id(resource_id)
         if application:
-            users = set([p.user for p in ResourceService.users_for_perm(application, 'view')])
+            users = set(
+                [p.user for p in ResourceService.users_for_perm(application, "view")]
+            )
             for user in users:
-                user.send_digest(request, application, reports=reports,
-                                 since_when=since_when)
+                user.send_digest(
+                    request, application, reports=reports, since_when=since_when
+                )
 
 
 @celery.task(queue="default")
@@ -610,11 +661,12 b' def notifications_reports():'
     Loop that checks redis for info and then issues new tasks to celery to
     issue notifications
     """
-    apps = Datastores.redis.smembers(REDIS_KEYS['apps_that_had_reports'])
-    Datastores.redis.delete(REDIS_KEYS['apps_that_had_reports'])
+    apps = Datastores.redis.smembers(REDIS_KEYS["apps_that_had_reports"])
+    Datastores.redis.delete(REDIS_KEYS["apps_that_had_reports"])
     for app in apps:
-        log.warning('Notify for app: %s' % app)
-        check_user_report_notifications.delay(app.decode('utf8'))
+        log.warning("Notify for app: %s" % app)
+        check_user_report_notifications.delay(app.decode("utf8"))
+
 
 @celery.task(queue="default")
 def alerting_reports():
@@ -624,34 +676,33 b' def alerting_reports():'
     - which applications should have new alerts opened
     """
 
-    apps = Datastores.redis.smembers(REDIS_KEYS['apps_that_had_reports_alerting'])
-    Datastores.redis.delete(REDIS_KEYS['apps_that_had_reports_alerting'])
+    apps = Datastores.redis.smembers(REDIS_KEYS["apps_that_had_reports_alerting"])
+    Datastores.redis.delete(REDIS_KEYS["apps_that_had_reports_alerting"])
     for app in apps:
-        log.warning('Notify for app: %s' % app)
-        check_alerts.delay(app.decode('utf8'))
+        log.warning("Notify for app: %s" % app)
+        check_alerts.delay(app.decode("utf8"))
 
 
[e-mail](queue="default", soft_time_limit=3600 * 4,
-             hard_time_limit=3600 * 4, max_retries=144)
[e-mail](
+    queue="default", soft_time_limit=3600 * 4, hard_time_limit=3600 * 4, max_retries=144
+)
 def logs_cleanup(resource_id, filter_settings):
     request = get_current_request()
     request.tm.begin()
     es_query = {
         "query": {
-            "filtered": {
-                "filter": {
-                    "and": [{"term": {"resource_id": resource_id}}]
-                }
-            }
+            "filtered": {"filter": {"and": [{"term": {"resource_id": resource_id}}]}}
         }
     }
 
     query = DBSession.query(Log).filter(Log.resource_id == resource_id)
-    if filter_settings['namespace']:
-        query = query.filter(Log.namespace == filter_settings['namespace'][0])
-        es_query['query']['filtered']['filter']['and'].append(
-            {"term": {"namespace": filter_settings['namespace'][0]}}
+    if filter_settings["namespace"]:
+        query = query.filter(Log.namespace == filter_settings["namespace"][0])
+        es_query["query"]["filtered"]["filter"]["and"].append(
+            {"term": {"namespace": filter_settings["namespace"][0]}}
         )
     query.delete(synchronize_session=False)
     request.tm.commit()
-    Datastores.es.transport.perform_request("DELETE", '/{}/{}/_query'.format('rcae_l_*', 'log'), body=es_query)
+    Datastores.es.transport.perform_request(
+        "DELETE", "/{}/{}/_query".format("rcae_l_*", "log"), body=es_query
+    )

backend/src/appenlight/fil.py

@@ -14,6 +14,7 b''
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 def filter_callable(structure, section=None):
-    structure['SOMEVAL'] = '***REMOVED***'
+    structure["SOMEVAL"] = "***REMOVED***"
     return structure

backend/src/appenlight/forms.py

@@ -43,7 +43,7 b' _ = str'
 strip_filter = lambda x: x.strip() if x else None
 uppercase_filter = lambda x: x.upper() if x else None
 
-FALSE_VALUES = ('false', '', False, None)
+FALSE_VALUES = ("false", "", False, None)
 
 
 class CSRFException(Exception):
@@ -51,11 +51,14 b' class CSRFException(Exception):'
 
 
 class ReactorForm(SecureForm):
-    def __init__(self, formdata=None, obj=None, prefix='', csrf_context=None,
-                 **kwargs):
-        super(ReactorForm, self).__init__(formdata=formdata, obj=obj,
+    def __init__(self, formdata=None, obj=None, prefix="", csrf_context=None, **kwargs):
+        super(ReactorForm, self).__init__(
+            formdata=formdata,
+            obj=obj,
                                           prefix=prefix,
-                                          csrf_context=csrf_context, **kwargs)
+            csrf_context=csrf_context,
+            **kwargs
+        )
         self._csrf_context = csrf_context
 
     def generate_csrf_token(self, csrf_context):
@@ -63,14 +66,14 b' class ReactorForm(SecureForm):'
 
     def validate_csrf_token(self, field):
         request = self._csrf_context or pyramid.threadlocal.get_current_request()
-        is_from_auth_token = 'auth:auth_token' in request.effective_principals
+        is_from_auth_token = "auth:auth_token" in request.effective_principals
         if is_from_auth_token:
             return True
 
         if field.data != field.current_token:
             # try to save the day by using token from angular
-            if request.headers.get('X-XSRF-TOKEN') != field.current_token:
-                raise CSRFException('Invalid CSRF token')
+            if request.headers.get("X-XSRF-TOKEN") != field.current_token:
+                raise CSRFException("Invalid CSRF token")
 
     @property
     def errors_dict(self):
@@ -105,45 +108,47 b' class ReactorForm(SecureForm):'
 
 class SignInForm(ReactorForm):
     came_from = wtforms.HiddenField()
-    sign_in_user_name = wtforms.StringField(_('User Name'))
-    sign_in_user_password = wtforms.PasswordField(_('Password'))
+    sign_in_user_name = wtforms.StringField(_("User Name"))
+    sign_in_user_password = wtforms.PasswordField(_("Password"))
 
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
-    html_attrs = {'sign_in_user_name': {'placeholder': 'Your login'},
-                  'sign_in_user_password': {
-                      'placeholder': 'Your password'}}
+    html_attrs = {
+        "sign_in_user_name": {"placeholder": "Your login"},
+        "sign_in_user_password": {"placeholder": "Your password"},
+    }
 
 
 from wtforms.widgets import html_params, HTMLString
 
 
-def select_multi_checkbox(field, ul_class='set', **kwargs):
+def select_multi_checkbox(field, ul_class="set", **kwargs):
     """Render a multi-checkbox widget"""
-    kwargs.setdefault('type', 'checkbox')
-    field_id = kwargs.pop('id', field.id)
-    html = ['<ul %s>' % html_params(id=field_id, class_=ul_class)]
+    kwargs.setdefault("type", "checkbox")
+    field_id = kwargs.pop("id", field.id)
+    html = ["<ul %s>" % html_params(id=field_id, class_=ul_class)]
     for value, label, checked in field.iter_choices():
-        choice_id = '%s-%s' % (field_id, value)
+        choice_id = "%s-%s" % (field_id, value)
         options = dict(kwargs, name=field.name, value=value, id=choice_id)
         if checked:
-            options['checked'] = 'checked'
-        html.append('<li><input %s /> ' % html_params(**options))
+            options["checked"] = "checked"
+        html.append("<li><input %s /> " % html_params(**options))
         html.append('<label for="%s">%s</label></li>' % (choice_id, label))
-    html.append('</ul>')
-    return HTMLString(''.join(html))
+    html.append("</ul>")
+    return HTMLString("".join(html))
 
 
-def button_widget(field, button_cls='ButtonField btn btn-default', **kwargs):
+def button_widget(field, button_cls="ButtonField btn btn-default", **kwargs):
     """Render a button widget"""
-    kwargs.setdefault('type', 'button')
-    field_id = kwargs.pop('id', field.id)
-    kwargs.setdefault('value', field.label.text)
-    html = ['<button %s>%s</button>' % (html_params(id=field_id,
-                                                     class_=button_cls),
-                                         kwargs['value'],)]
-    return HTMLString(''.join(html))
+    kwargs.setdefault("type", "button")
+    field_id = kwargs.pop("id", field.id)
+    kwargs.setdefault("value", field.label.text)
+    html = [
+        "<button %s>%s</button>"
+        % (html_params(id=field_id, class_=button_cls), kwargs["value"])
+    ]
+    return HTMLString("".join(html))
 
 
 def clean_whitespace(value):
@@ -157,33 +162,32 b' def found_username_validator(form, field):'
     # sets user to recover in email validator
     form.field_user = user
     if not user:
-        raise wtforms.ValidationError('This username does not exist')
+        raise wtforms.ValidationError("This username does not exist")
 
 
 def found_username_email_validator(form, field):
     user = UserService.by_email(field.data)
     if not user:
-        raise wtforms.ValidationError('Email is incorrect')
+        raise wtforms.ValidationError("Email is incorrect")
 
 
 def unique_username_validator(form, field):
     user = UserService.by_user_name(field.data)
     if user:
-        raise wtforms.ValidationError('This username already exists in system')
+        raise wtforms.ValidationError("This username already exists in system")
 
 
 def unique_groupname_validator(form, field):
     group = GroupService.by_group_name(field.data)
-    mod_group = getattr(form, '_modified_group', None)
+    mod_group = getattr(form, "_modified_group", None)
     if group and (not mod_group or mod_group.id != group.id):
-        raise wtforms.ValidationError(
-            'This group name already exists in system')
+        raise wtforms.ValidationError("This group name already exists in system")
 
 
 def unique_email_validator(form, field):
     user = UserService.by_email(field.data)
     if user:
-        raise wtforms.ValidationError('This email already exists in system')
+        raise wtforms.ValidationError("This email already exists in system")
 
 
 def email_validator(form, field):
@@ -196,145 +200,168 b' def email_validator(form, field):'
 
 def unique_alert_email_validator(form, field):
     q = DBSession.query(AlertChannel)
-    q = q.filter(AlertChannel.channel_name == 'email')
+    q = q.filter(AlertChannel.channel_name == "email")
     q = q.filter(AlertChannel.channel_value == field.data)
     email = q.first()
     if email:
-        raise wtforms.ValidationError(
-            'This email already exists in alert system')
+        raise wtforms.ValidationError("This email already exists in alert system")
 
 
 def blocked_email_validator(form, field):
     blocked_emails = [
-        'goood-mail.org',
-        'shoeonlineblog.com',
-        'louboutinemart.com',
-        'guccibagshere.com',
-        'nikeshoesoutletforsale.com'
+        "goood-mail.org",
+        "shoeonlineblog.com",
+        "louboutinemart.com",
+        "guccibagshere.com",
+        "nikeshoesoutletforsale.com",
     ]
-    data = field.data or ''
-    domain = data.split('@')[-1]
+    data = field.data or ""
+    domain = data.split("@")[-1]
     if domain in blocked_emails:
-        raise wtforms.ValidationError('Don\'t spam')
+        raise wtforms.ValidationError("Don't spam")
 
 
 def old_password_validator(form, field):
-    if not UserService.check_password(field.user, field.data or ''):
-        raise wtforms.ValidationError('You need to enter correct password')
+    if not UserService.check_password(field.user, field.data or ""):
+        raise wtforms.ValidationError("You need to enter correct password")
 
 
 class UserRegisterForm(ReactorForm):
     user_name = wtforms.StringField(
-        _('User Name'),
+        _("User Name"),
         filters=[strip_filter],
         validators=[
             wtforms.validators.Length(min=2, max=30),
             wtforms.validators.Regexp(
-                re.compile(r'^[\.\w-]+$', re.UNICODE),
-                message="Invalid characters used"),
+                re.compile(r"^[\.\w-]+$", re.UNICODE), message="Invalid characters used"
+            ),
             unique_username_validator,
-            wtforms.validators.DataRequired()
-        ])
+            wtforms.validators.DataRequired(),
+        ],
+    )
 
-    user_password = wtforms.PasswordField(_('User Password'),
+    user_password = wtforms.PasswordField(
+        _("User Password"),
                                           filters=[strip_filter],
                                           validators=[
                                               wtforms.validators.Length(min=4),
-                                              wtforms.validators.DataRequired()
-                                          ])
+            wtforms.validators.DataRequired(),
+        ],
+    )
 
-    email = wtforms.StringField(_('Email Address'),
+    email = wtforms.StringField(
+        _("Email Address"),
                                 filters=[strip_filter],
-                                validators=[email_validator,
+        validators=[
+            email_validator,
                                             unique_email_validator,
                                             blocked_email_validator,
-                                            wtforms.validators.DataRequired()])
-    first_name = wtforms.HiddenField(_('First Name'))
-    last_name = wtforms.HiddenField(_('Last Name'))
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    first_name = wtforms.HiddenField(_("First Name"))
+    last_name = wtforms.HiddenField(_("Last Name"))
 
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
-    html_attrs = {'user_name': {'placeholder': 'Your login'},
-                  'user_password': {'placeholder': 'Your password'},
-                  'email': {'placeholder': 'Your email'}}
+    html_attrs = {
+        "user_name": {"placeholder": "Your login"},
+        "user_password": {"placeholder": "Your password"},
+        "email": {"placeholder": "Your email"},
+    }
 
 
 class UserCreateForm(UserRegisterForm):
-    status = wtforms.BooleanField('User status',
-                                  false_values=FALSE_VALUES)
+    status = wtforms.BooleanField("User status", false_values=FALSE_VALUES)
 
 
 class UserUpdateForm(UserCreateForm):
     user_name = None
-    user_password = wtforms.PasswordField(_('User Password'),
+    user_password = wtforms.PasswordField(
+        _("User Password"),
                                           filters=[strip_filter],
-                                          validators=[
-                                              wtforms.validators.Length(min=4),
-                                              wtforms.validators.Optional()
-                                          ])
-    email = wtforms.StringField(_('Email Address'),
+        validators=[wtforms.validators.Length(min=4), wtforms.validators.Optional()],
+    )
+    email = wtforms.StringField(
+        _("Email Address"),
                                 filters=[strip_filter],
-                                validators=[email_validator,
-                                            wtforms.validators.DataRequired()])
+        validators=[email_validator, wtforms.validators.DataRequired()],
+    )
 
 
 class LostPasswordForm(ReactorForm):
-    email = wtforms.StringField(_('Email Address'),
+    email = wtforms.StringField(
+        _("Email Address"),
                                 filters=[strip_filter],
-                                validators=[email_validator,
+        validators=[
+            email_validator,
                                             found_username_email_validator,
-                                            wtforms.validators.DataRequired()])
+            wtforms.validators.DataRequired(),
+        ],
+    )
 
-    submit = wtforms.SubmitField(_('Reset password'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    submit = wtforms.SubmitField(_("Reset password"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class ChangePasswordForm(ReactorForm):
     old_password = wtforms.PasswordField(
-        'Old Password',
+        "Old Password",
         filters=[strip_filter],
-        validators=[old_password_validator,
-                    wtforms.validators.DataRequired()])
+        validators=[old_password_validator, wtforms.validators.DataRequired()],
+    )
 
     new_password = wtforms.PasswordField(
-        'New Password',
+        "New Password",
         filters=[strip_filter],
-        validators=[wtforms.validators.Length(min=4),
-                    wtforms.validators.DataRequired()])
+        validators=[
+            wtforms.validators.Length(min=4),
+            wtforms.validators.DataRequired(),
+        ],
+    )
     new_password_confirm = wtforms.PasswordField(
-        'Confirm Password',
+        "Confirm Password",
         filters=[strip_filter],
-        validators=[wtforms.validators.EqualTo('new_password'),
-                    wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField('Change Password')
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+        validators=[
+            wtforms.validators.EqualTo("new_password"),
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    submit = wtforms.SubmitField("Change Password")
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class CheckPasswordForm(ReactorForm):
     password = wtforms.PasswordField(
-        'Password',
+        "Password",
         filters=[strip_filter],
-        validators=[old_password_validator,
-                    wtforms.validators.DataRequired()])
+        validators=[old_password_validator, wtforms.validators.DataRequired()],
+    )
 
 
 class NewPasswordForm(ReactorForm):
     new_password = wtforms.PasswordField(
-        'New Password',
+        "New Password",
         filters=[strip_filter],
-        validators=[wtforms.validators.Length(min=4),
-                    wtforms.validators.DataRequired()])
+        validators=[
+            wtforms.validators.Length(min=4),
+            wtforms.validators.DataRequired(),
+        ],
+    )
     new_password_confirm = wtforms.PasswordField(
-        'Confirm Password',
+        "Confirm Password",
         filters=[strip_filter],
-        validators=[wtforms.validators.EqualTo('new_password'),
-                    wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField('Set Password')
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+        validators=[
+            wtforms.validators.EqualTo("new_password"),
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    submit = wtforms.SubmitField("Set Password")
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class CORSTextAreaField(wtforms.StringField):
@@ -342,261 +369,290 b' class CORSTextAreaField(wtforms.StringField):'
     This field represents an HTML ``<textarea>`` and can be used to take
     multi-line input.
     """
+
     widget = wtforms.widgets.TextArea()
 
     def process_formdata(self, valuelist):
         self.data = []
         if valuelist:
-            data = [x.strip() for x in valuelist[0].split('\n')]
+            data = [x.strip() for x in valuelist[0].split("\n")]
             for d in data:
                 if not d:
                     continue
-                if d.startswith('www.'):
+                if d.startswith("www."):
                     d = d[4:]
                 if data:
                     self.data.append(d)
         else:
             self.data = []
-        self.data = '\n'.join(self.data)
+        self.data = "\n".join(self.data)
 
 
 class ApplicationCreateForm(ReactorForm):
     resource_name = wtforms.StringField(
-        _('Application name'),
+        _("Application name"),
         filters=[strip_filter],
-        validators=[wtforms.validators.Length(min=1),
-                    wtforms.validators.DataRequired()])
+        validators=[
+            wtforms.validators.Length(min=1),
+            wtforms.validators.DataRequired(),
+        ],
+    )
 
     domains = CORSTextAreaField(
-        _('Domain names for CORS headers '),
-        validators=[wtforms.validators.Length(min=1),
-                    wtforms.validators.Optional()],
-        description='Required for Javascript error '
-                    'tracking (one line one domain, skip http:// part)')
+        _("Domain names for CORS headers "),
+        validators=[wtforms.validators.Length(min=1), wtforms.validators.Optional()],
+        description="Required for Javascript error "
+        "tracking (one line one domain, skip http:// part)",
+    )
 
-    submit = wtforms.SubmitField(_('Create Application'))
+    submit = wtforms.SubmitField(_("Create Application"))
 
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
-    html_attrs = {'resource_name': {'placeholder': 'Application Name'},
-                  'uptime_url': {'placeholder': 'http://somedomain.com'}}
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
+    html_attrs = {
+        "resource_name": {"placeholder": "Application Name"},
+        "uptime_url": {"placeholder": "http://somedomain.com"},
+    }
 
 
 class ApplicationUpdateForm(ApplicationCreateForm):
     default_grouping = wtforms.SelectField(
-        _('Default grouping for errors'),
-        choices=[('url_type', 'Error Type + location',),
-                 ('url_traceback', 'Traceback + location',),
-                 ('traceback_server', 'Traceback + Server',)],
-        default='url_traceback')
+        _("Default grouping for errors"),
+        choices=[
+            ("url_type", "Error Type + location"),
+            ("url_traceback", "Traceback + location"),
+            ("traceback_server", "Traceback + Server"),
+        ],
+        default="url_traceback",
+    )
 
     error_report_threshold = wtforms.IntegerField(
-        _('Alert on error reports'),
+        _("Alert on error reports"),
         validators=[
             wtforms.validators.NumberRange(min=1),
-            wtforms.validators.DataRequired()
+            wtforms.validators.DataRequired(),
         ],
-        description='Application requires to send at least this amount of '
-                    'error reports per minute to open alert'
+        description="Application requires to send at least this amount of "
+        "error reports per minute to open alert",
     )
 
     slow_report_threshold = wtforms.IntegerField(
-        _('Alert on slow reports'),
-        validators=[wtforms.validators.NumberRange(min=1),
-                    wtforms.validators.DataRequired()],
-        description='Application requires to send at least this amount of '
-                    'slow reports per minute to open alert')
+        _("Alert on slow reports"),
+        validators=[
+            wtforms.validators.NumberRange(min=1),
+            wtforms.validators.DataRequired(),
+        ],
+        description="Application requires to send at least this amount of "
+        "slow reports per minute to open alert",
+    )
 
     allow_permanent_storage = wtforms.BooleanField(
-        _('Permanent logs'),
+        _("Permanent logs"),
         false_values=FALSE_VALUES,
-        description=_(
-            'Allow permanent storage of logs in separate DB partitions'))
+        description=_("Allow permanent storage of logs in separate DB partitions"),
+    )
 
-    submit = wtforms.SubmitField(_('Create Application'))
+    submit = wtforms.SubmitField(_("Create Application"))
 
 
 class UserSearchSchemaForm(ReactorForm):
-    user_name = wtforms.StringField('User Name',
-                                    filters=[strip_filter], )
+    user_name = wtforms.StringField("User Name", filters=[strip_filter])
 
-    submit = wtforms.SubmitField(_('Search User'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    submit = wtforms.SubmitField(_("Search User"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
     '<li class="user_exists"><span></span></li>'
 
 
 class YesNoForm(ReactorForm):
-    no = wtforms.SubmitField('No', default='')
-    yes = wtforms.SubmitField('Yes', default='')
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    no = wtforms.SubmitField("No", default="")
+    yes = wtforms.SubmitField("Yes", default="")
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
-status_codes = [('', 'All',), ('500', '500',), ('404', '404',)]
+status_codes = [("", "All"), ("500", "500"), ("404", "404")]
 
-priorities = [('', 'All',)]
+priorities = [("", "All")]
 for i in range(1, 11):
-    priorities.append((str(i), str(i),))
-
-report_status_choices = [('', 'All',),
-                         ('never_reviewed', 'Never revieved',),
-                         ('reviewed', 'Revieved',),
-                         ('public', 'Public',),
-                         ('fixed', 'Fixed',), ]
+    priorities.append((str(i), str(i)))
+
+report_status_choices = [
+    ("", "All"),
+    ("never_reviewed", "Never revieved"),
+    ("reviewed", "Revieved"),
+    ("public", "Public"),
+    ("fixed", "Fixed"),
+]
 
 
 class ReportBrowserForm(ReactorForm):
-    applications = wtforms.SelectMultipleField('Applications',
-                                               widget=select_multi_checkbox)
-    http_status = wtforms.SelectField('HTTP Status', choices=status_codes)
-    priority = wtforms.SelectField('Priority', choices=priorities, default='')
-    start_date = wtforms.DateField('Start Date')
-    end_date = wtforms.DateField('End Date')
-    error = wtforms.StringField('Error')
-    url_path = wtforms.StringField('URL Path')
-    url_domain = wtforms.StringField('URL Domain')
-    report_status = wtforms.SelectField('Report status',
-                                        choices=report_status_choices,
-                                        default='')
-    submit = wtforms.SubmitField('<span class="glyphicon glyphicon-search">'
-                                 '</span> Filter results',
-                                 widget=button_widget)
-
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
-
-
-slow_report_status_choices = [('', 'All',),
-                              ('never_reviewed', 'Never revieved',),
-                              ('reviewed', 'Revieved',),
-                              ('public', 'Public',), ]
+    applications = wtforms.SelectMultipleField(
+        "Applications", widget=select_multi_checkbox
+    )
+    http_status = wtforms.SelectField("HTTP Status", choices=status_codes)
+    priority = wtforms.SelectField("Priority", choices=priorities, default="")
+    start_date = wtforms.DateField("Start Date")
+    end_date = wtforms.DateField("End Date")
+    error = wtforms.StringField("Error")
+    url_path = wtforms.StringField("URL Path")
+    url_domain = wtforms.StringField("URL Domain")
+    report_status = wtforms.SelectField(
+        "Report status", choices=report_status_choices, default=""
+    )
+    submit = wtforms.SubmitField(
+        '<span class="glyphicon glyphicon-search">' "</span> Filter results",
+        widget=button_widget,
+    )
+
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
+
+
+slow_report_status_choices = [
+    ("", "All"),
+    ("never_reviewed", "Never revieved"),
+    ("reviewed", "Revieved"),
+    ("public", "Public"),
+]
 
 
 class BulkOperationForm(ReactorForm):
-    applications = wtforms.SelectField('Applications')
+    applications = wtforms.SelectField("Applications")
     start_date = wtforms.DateField(
-        'Start Date',
-        default=lambda: datetime.datetime.utcnow() - datetime.timedelta(
-            days=90))
-    end_date = wtforms.DateField('End Date')
+        "Start Date",
+        default=lambda: datetime.datetime.utcnow() - datetime.timedelta(days=90),
+    )
+    end_date = wtforms.DateField("End Date")
     confirm = wtforms.BooleanField(
-        'Confirm operation',
-        validators=[wtforms.validators.DataRequired()])
+        "Confirm operation", validators=[wtforms.validators.DataRequired()]
+    )
 
 
 class LogBrowserForm(ReactorForm):
-    applications = wtforms.SelectMultipleField('Applications',
-                                               widget=select_multi_checkbox)
-    start_date = wtforms.DateField('Start Date')
-    log_level = wtforms.StringField('Log level')
-    message = wtforms.StringField('Message')
-    namespace = wtforms.StringField('Namespace')
+    applications = wtforms.SelectMultipleField(
+        "Applications", widget=select_multi_checkbox
+    )
+    start_date = wtforms.DateField("Start Date")
+    log_level = wtforms.StringField("Log level")
+    message = wtforms.StringField("Message")
+    namespace = wtforms.StringField("Namespace")
     submit = wtforms.SubmitField(
         '<span class="glyphicon glyphicon-search"></span> Filter results',
-        widget=button_widget)
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+        widget=button_widget,
+    )
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class CommentForm(ReactorForm):
-    body = wtforms.TextAreaField('Comment', validators=[
+    body = wtforms.TextAreaField(
+        "Comment",
+        validators=[
         wtforms.validators.Length(min=1),
-        wtforms.validators.DataRequired()
-    ])
-    submit = wtforms.SubmitField('Comment', )
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    submit = wtforms.SubmitField("Comment")
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class EmailChannelCreateForm(ReactorForm):
-    email = wtforms.StringField(_('Email Address'),
+    email = wtforms.StringField(
+        _("Email Address"),
                                 filters=[strip_filter],
-                                validators=[email_validator,
+        validators=[
+            email_validator,
                                             unique_alert_email_validator,
-                                            wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField('Add email channel', )
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    submit = wtforms.SubmitField("Add email channel")
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 def gen_user_profile_form():
     class UserProfileForm(ReactorForm):
         email = wtforms.StringField(
-            _('Email Address'),
-            validators=[email_validator, wtforms.validators.DataRequired()])
-        first_name = wtforms.StringField(_('First Name'))
-        last_name = wtforms.StringField(_('Last Name'))
-        company_name = wtforms.StringField(_('Company Name'))
-        company_address = wtforms.TextAreaField(_('Company Address'))
-        zip_code = wtforms.StringField(_('ZIP code'))
-        city = wtforms.StringField(_('City'))
-        notifications = wtforms.BooleanField('Account notifications',
-                                             false_values=FALSE_VALUES)
-        submit = wtforms.SubmitField(_('Update Account'))
-        ignore_labels = ['submit']
-        css_classes = {'submit': 'btn btn-primary'}
+            _("Email Address"),
+            validators=[email_validator, wtforms.validators.DataRequired()],
+        )
+        first_name = wtforms.StringField(_("First Name"))
+        last_name = wtforms.StringField(_("Last Name"))
+        company_name = wtforms.StringField(_("Company Name"))
+        company_address = wtforms.TextAreaField(_("Company Address"))
+        zip_code = wtforms.StringField(_("ZIP code"))
+        city = wtforms.StringField(_("City"))
+        notifications = wtforms.BooleanField(
+            "Account notifications", false_values=FALSE_VALUES
+        )
+        submit = wtforms.SubmitField(_("Update Account"))
+        ignore_labels = ["submit"]
+        css_classes = {"submit": "btn btn-primary"}
 
     return UserProfileForm
 
 
 class PurgeAppForm(ReactorForm):
     resource_id = wtforms.HiddenField(
-        'App Id',
-        validators=[wtforms.validators.DataRequired()])
-    days = wtforms.IntegerField(
-        'Days',
-        validators=[wtforms.validators.DataRequired()])
+        "App Id", validators=[wtforms.validators.DataRequired()]
+    )
+    days = wtforms.IntegerField("Days", validators=[wtforms.validators.DataRequired()])
     password = wtforms.PasswordField(
-        'Admin Password',
-        validators=[old_password_validator, wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField(_('Purge Data'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+        "Admin Password",
+        validators=[old_password_validator, wtforms.validators.DataRequired()],
+    )
+    submit = wtforms.SubmitField(_("Purge Data"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class IntegrationRepoForm(ReactorForm):
-    host_name = wtforms.StringField("Service Host", default='')
+    host_name = wtforms.StringField("Service Host", default="")
     user_name = wtforms.StringField(
         "User Name",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired(),
-                    wtforms.validators.Length(min=1)])
+        validators=[
+            wtforms.validators.DataRequired(),
+            wtforms.validators.Length(min=1),
+        ],
+    )
     repo_name = wtforms.StringField(
         "Repo Name",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired(),
-                    wtforms.validators.Length(min=1)])
+        validators=[
+            wtforms.validators.DataRequired(),
+            wtforms.validators.Length(min=1),
+        ],
+    )
 
 
 class IntegrationBitbucketForm(IntegrationRepoForm):
-    host_name = wtforms.StringField("Service Host",
-                                    default='https://bitbucket.org')
+    host_name = wtforms.StringField("Service Host", default="https://bitbucket.org")
 
     def validate_user_name(self, field):
         try:
             request = pyramid.threadlocal.get_current_request()
             client = BitbucketIntegration.create_client(
-                request,
-                self.user_name.data,
-                self.repo_name.data)
+                request, self.user_name.data, self.repo_name.data
+            )
             client.get_assignees()
         except IntegrationException as e:
             raise wtforms.validators.ValidationError(str(e))
 
 
 class IntegrationGithubForm(IntegrationRepoForm):
-    host_name = wtforms.StringField("Service Host",
-                                    default='https://github.com')
+    host_name = wtforms.StringField("Service Host", default="https://github.com")
 
     def validate_user_name(self, field):
         try:
             request = pyramid.threadlocal.get_current_request()
             client = GithubIntegration.create_client(
-                request,
-                self.user_name.data,
-                self.repo_name.data)
+                request, self.user_name.data, self.repo_name.data
+            )
             client.get_assignees()
         except IntegrationException as e:
             raise wtforms.validators.ValidationError(str(e))
@@ -605,25 +661,28 b' class IntegrationGithubForm(IntegrationRepoForm):'
 
 def filter_rooms(data):
     if data is not None:
-        rooms = data.split(',')
-        return ','.join([r.strip() for r in rooms])
+        rooms = data.split(",")
+        return ",".join([r.strip() for r in rooms])
 
 
 class IntegrationCampfireForm(ReactorForm):
     account = wtforms.StringField(
-        'Account',
+        "Account",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     api_token = wtforms.StringField(
-        'Api Token',
+        "Api Token",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
-    rooms = wtforms.StringField('Room ID list', filters=[filter_rooms])
+        validators=[wtforms.validators.DataRequired()],
+    )
+    rooms = wtforms.StringField("Room ID list", filters=[filter_rooms])
 
     def validate_api_token(self, field):
         try:
-            client = CampfireIntegration.create_client(self.api_token.data,
-                                                       self.account.data)
+            client = CampfireIntegration.create_client(
+                self.api_token.data, self.account.data
+            )
             client.get_account()
         except IntegrationException as e:
             raise wtforms.validators.ValidationError(str(e))
@@ -631,17 +690,18 b' class IntegrationCampfireForm(ReactorForm):'
     def validate_rooms(self, field):
         if not field.data:
             return
-        client = CampfireIntegration.create_client(self.api_token.data,
-                                                   self.account.data)
+        client = CampfireIntegration.create_client(
+            self.api_token.data, self.account.data
+        )
 
         try:
-            room_list = [r['id'] for r in client.get_rooms()]
+            room_list = [r["id"] for r in client.get_rooms()]
         except IntegrationException as e:
             raise wtforms.validators.ValidationError(str(e))
 
-        rooms = field.data.split(',')
+        rooms = field.data.split(",")
         if len(rooms) > 3:
-            msg = 'You can use up to 3 room ids'
+            msg = "You can use up to 3 room ids"
             raise wtforms.validators.ValidationError(msg)
         if rooms:
             for room_id in rooms:
@@ -649,75 +709,78 b' class IntegrationCampfireForm(ReactorForm):'
                     msg = "Room %s doesn't exist"
                     raise wtforms.validators.ValidationError(msg % room_id)
                 if not room_id.strip().isdigit():
-                    msg = 'You must use only integers for room ids'
+                    msg = "You must use only integers for room ids"
                     raise wtforms.validators.ValidationError(msg)
 
-    submit = wtforms.SubmitField(_('Connect to Campfire'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+    submit = wtforms.SubmitField(_("Connect to Campfire"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 def filter_rooms(data):
     if data is not None:
-        rooms = data.split(',')
-        return ','.join([r.strip() for r in rooms])
+        rooms = data.split(",")
+        return ",".join([r.strip() for r in rooms])
 
 
 class IntegrationHipchatForm(ReactorForm):
     api_token = wtforms.StringField(
-        'Api Token',
+        "Api Token",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     rooms = wtforms.StringField(
-        'Room ID list',
+        "Room ID list",
         filters=[filter_rooms],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
 
     def validate_rooms(self, field):
         if not field.data:
             return
         client = HipchatIntegration.create_client(self.api_token.data)
-        rooms = field.data.split(',')
+        rooms = field.data.split(",")
         if len(rooms) > 3:
-            msg = 'You can use up to 3 room ids'
+            msg = "You can use up to 3 room ids"
             raise wtforms.validators.ValidationError(msg)
         if rooms:
             for room_id in rooms:
                 if not room_id.strip().isdigit():
-                    msg = 'You must use only integers for room ids'
+                    msg = "You must use only integers for room ids"
                     raise wtforms.validators.ValidationError(msg)
                 try:
-                    client.send({
-                        "message_format": 'text',
+                    client.send(
+                        {
+                            "message_format": "text",
                         "message": "testing for room existence",
                         "from": "AppEnlight",
                         "room_id": room_id,
-                        "color": "green"
-                    })
+                            "color": "green",
+                        }
+                    )
                 except IntegrationException as exc:
-                    msg = 'Room id: %s exception: %s'
-                    raise wtforms.validators.ValidationError(msg % (room_id,
-                                                                    exc))
+                    msg = "Room id: %s exception: %s"
+                    raise wtforms.validators.ValidationError(msg % (room_id, exc))
 
 
 class IntegrationFlowdockForm(ReactorForm):
-    api_token = wtforms.StringField('API Token',
+    api_token = wtforms.StringField(
+        "API Token",
                                     filters=[strip_filter],
-                                    validators=[
-                                        wtforms.validators.DataRequired()
-                                    ], )
+        validators=[wtforms.validators.DataRequired()],
+    )
 
     def validate_api_token(self, field):
         try:
             client = FlowdockIntegration.create_client(self.api_token.data)
             registry = pyramid.threadlocal.get_current_registry()
             payload = {
-                "source": registry.settings['mailing.from_name'],
-                "from_address": registry.settings['mailing.from_email'],
+                "source": registry.settings["mailing.from_name"],
+                "from_address": registry.settings["mailing.from_email"],
                 "subject": "Integration test",
                 "content": "If you can see this it was successful",
                 "tags": ["appenlight"],
-                "link": registry.settings['mailing.app_url']
+                "link": registry.settings["mailing.app_url"],
             }
             client.send_to_inbox(payload)
         except IntegrationException as e:
@@ -726,30 +789,35 b' class IntegrationFlowdockForm(ReactorForm):'
 
 class IntegrationSlackForm(ReactorForm):
     webhook_url = wtforms.StringField(
-        'Reports webhook',
+        "Reports webhook",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
 
     def validate_webhook_url(self, field):
         registry = pyramid.threadlocal.get_current_registry()
         client = SlackIntegration.create_client(field.data)
-        link = "<%s|%s>" % (registry.settings['mailing.app_url'],
-                            registry.settings['mailing.from_name'])
+        link = "<%s|%s>" % (
+            registry.settings["mailing.app_url"],
+            registry.settings["mailing.from_name"],
+        )
         test_data = {
             "username": "AppEnlight",
             "icon_emoji": ":fire:",
             "attachments": [
-                {"fallback": "Testing integration channel: %s" % link,
+                {
+                    "fallback": "Testing integration channel: %s" % link,
                  "pretext": "Testing integration channel:  %s" % link,
                  "color": "good",
                  "fields": [
                      {
                          "title": "Status",
                          "value": "Integration is working fine",
-                         "short": False
+                            "short": False,
                      }
-                 ]}
-            ]
+                    ],
+                }
+            ],
         }
         try:
             client.make_request(data=test_data)
@@ -759,44 +827,52 b' class IntegrationSlackForm(ReactorForm):'
 
 class IntegrationWebhooksForm(ReactorForm):
     reports_webhook = wtforms.StringField(
-        'Reports webhook',
+        "Reports webhook",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     alerts_webhook = wtforms.StringField(
-        'Alerts webhook',
+        "Alerts webhook",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField(_('Setup webhooks'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-primary'}
+        validators=[wtforms.validators.DataRequired()],
+    )
+    submit = wtforms.SubmitField(_("Setup webhooks"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-primary"}
 
 
 class IntegrationJiraForm(ReactorForm):
     host_name = wtforms.StringField(
-        'Server URL',
+        "Server URL",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     user_name = wtforms.StringField(
-        'Username',
+        "Username",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     password = wtforms.PasswordField(
-        'Password',
+        "Password",
         filters=[strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
     project = wtforms.StringField(
-        'Project key',
+        "Project key",
         filters=[uppercase_filter, strip_filter],
-        validators=[wtforms.validators.DataRequired()])
+        validators=[wtforms.validators.DataRequired()],
+    )
 
     def validate_project(self, field):
         if not field.data:
             return
         try:
-            client = JiraClient(self.user_name.data,
+            client = JiraClient(
+                self.user_name.data,
                                 self.password.data,
                                 self.host_name.data,
-                                self.project.data)
+                self.project.data,
+            )
         except Exception as exc:
             raise wtforms.validators.ValidationError(str(exc))
 
@@ -809,88 +885,97 b' class IntegrationJiraForm(ReactorForm):'
 def get_deletion_form(resource):
     class F(ReactorForm):
         application_name = wtforms.StringField(
-            'Application Name',
+            "Application Name",
             filters=[strip_filter],
-            validators=[wtforms.validators.AnyOf([resource.resource_name])])
+            validators=[wtforms.validators.AnyOf([resource.resource_name])],
+        )
         resource_id = wtforms.HiddenField(default=resource.resource_id)
-        submit = wtforms.SubmitField(_('Delete my application'))
-        ignore_labels = ['submit']
-        css_classes = {'submit': 'btn btn-danger'}
+        submit = wtforms.SubmitField(_("Delete my application"))
+        ignore_labels = ["submit"]
+        css_classes = {"submit": "btn btn-danger"}
 
     return F
 
 
 class ChangeApplicationOwnerForm(ReactorForm):
     password = wtforms.PasswordField(
-        'Password',
+        "Password",
         filters=[strip_filter],
-        validators=[old_password_validator,
-                    wtforms.validators.DataRequired()])
+        validators=[old_password_validator, wtforms.validators.DataRequired()],
+    )
 
     user_name = wtforms.StringField(
-        'New owners username',
+        "New owners username",
         filters=[strip_filter],
-        validators=[found_username_validator,
-                    wtforms.validators.DataRequired()])
-    submit = wtforms.SubmitField(_('Transfer ownership of application'))
-    ignore_labels = ['submit']
-    css_classes = {'submit': 'btn btn-danger'}
+        validators=[found_username_validator, wtforms.validators.DataRequired()],
+    )
+    submit = wtforms.SubmitField(_("Transfer ownership of application"))
+    ignore_labels = ["submit"]
+    css_classes = {"submit": "btn btn-danger"}
 
 
 def default_filename():
-    return 'Invoice %s' % datetime.datetime.utcnow().strftime('%Y/%m')
+    return "Invoice %s" % datetime.datetime.utcnow().strftime("%Y/%m")
 
 
 class FileUploadForm(ReactorForm):
-    title = wtforms.StringField('File Title',
+    title = wtforms.StringField(
+        "File Title",
                                 default=default_filename,
-                                validators=[wtforms.validators.DataRequired()])
-    file = wtforms.FileField('File')
+        validators=[wtforms.validators.DataRequired()],
+    )
+    file = wtforms.FileField("File")
 
     def validate_file(self, field):
-        if not hasattr(field.data, 'file'):
-            raise wtforms.ValidationError('File is missing')
+        if not hasattr(field.data, "file"):
+            raise wtforms.ValidationError("File is missing")
 
-    submit = wtforms.SubmitField(_('Upload'))
+    submit = wtforms.SubmitField(_("Upload"))
 
 
 def get_partition_deletion_form(es_indices, pg_indices):
     class F(ReactorForm):
-        es_index = wtforms.SelectMultipleField('Elasticsearch',
-                                               choices=[(ix, '') for ix in
-                                                        es_indices])
-        pg_index = wtforms.SelectMultipleField('pg',
-                                               choices=[(ix, '') for ix in
-                                                        pg_indices])
-        confirm = wtforms.TextField('Confirm',
+        es_index = wtforms.SelectMultipleField(
+            "Elasticsearch", choices=[(ix, "") for ix in es_indices]
+        )
+        pg_index = wtforms.SelectMultipleField(
+            "pg", choices=[(ix, "") for ix in pg_indices]
+        )
+        confirm = wtforms.TextField(
+            "Confirm",
                                     filters=[uppercase_filter, strip_filter],
                                     validators=[
-                                        wtforms.validators.AnyOf(['CONFIRM']),
-                                        wtforms.validators.DataRequired()])
-        ignore_labels = ['submit']
-        css_classes = {'submit': 'btn btn-danger'}
+                wtforms.validators.AnyOf(["CONFIRM"]),
+                wtforms.validators.DataRequired(),
+            ],
+        )
+        ignore_labels = ["submit"]
+        css_classes = {"submit": "btn btn-danger"}
 
     return F
 
 
 class GroupCreateForm(ReactorForm):
     group_name = wtforms.StringField(
-        _('Group Name'),
+        _("Group Name"),
         filters=[strip_filter],
         validators=[
             wtforms.validators.Length(min=2, max=50),
             unique_groupname_validator,
-            wtforms.validators.DataRequired()
-        ])
-    description = wtforms.StringField(_('Group description'))
+            wtforms.validators.DataRequired(),
+        ],
+    )
+    description = wtforms.StringField(_("Group description"))
 
 
-time_choices = [(k, v['label'],) for k, v in h.time_deltas.items()]
+time_choices = [(k, v["label"]) for k, v in h.time_deltas.items()]
 
 
 class AuthTokenCreateForm(ReactorForm):
-    description = wtforms.StringField(_('Token description'))
-    expires = wtforms.SelectField('Expires',
+    description = wtforms.StringField(_("Token description"))
+    expires = wtforms.SelectField(
+        "Expires",
                                   coerce=lambda x: x,
                                   choices=time_choices,
-                                  validators=[wtforms.validators.Optional()])
+        validators=[wtforms.validators.Optional()],
+    )

backend/src/appenlight/lib/__init__.py

@@ -24,20 +24,20 b' from appenlight_client.exceptions import get_current_traceback'
 
 
 def generate_random_string(chars=10):
-    return ''.join(random.sample(string.ascii_letters * 2 + string.digits,
-                                 chars))
+    return "".join(random.sample(string.ascii_letters * 2 + string.digits, chars))
 
 
 def to_integer_safe(input):
     try:
         return int(input)
-    except (TypeError, ValueError,):
+    except (TypeError, ValueError):
         return None
 
 
 def print_traceback(log):
-    traceback = get_current_traceback(skip=1, show_hidden_frames=True,
-                                      ignore_system_exceptions=True)
+    traceback = get_current_traceback(
+        skip=1, show_hidden_frames=True, ignore_system_exceptions=True
+    )
     exception_text = traceback.exception
     log.error(exception_text)
     log.error(traceback.plaintext)
@@ -45,6 +45,5 b' def print_traceback(log):'
 
 
 def get_callable(import_string):
-    import_module, indexer_callable = import_string.split(':')
-    return getattr(importlib.import_module(import_module),
-                   indexer_callable)
+    import_module, indexer_callable = import_string.split(":")
+    return getattr(importlib.import_module(import_module), indexer_callable)

backend/src/appenlight/lib/api.py

@@ -27,21 +27,18 b' log = logging.getLogger(__name__)'
 
 def rate_limiting(request, resource, section, to_increment=1):
     tsample = datetime.datetime.utcnow().replace(second=0, microsecond=0)
-    key = REDIS_KEYS['rate_limits'][section].format(tsample,
-                                                    resource.resource_id)
+    key = REDIS_KEYS["rate_limits"][section].format(tsample, resource.resource_id)
     redis_pipeline = request.registry.redis_conn.pipeline()
     redis_pipeline.incr(key, to_increment)
     redis_pipeline.expire(key, 3600 * 24)
     results = redis_pipeline.execute()
     current_count = results[0]
-    config = ConfigService.by_key_and_section(section, 'global')
+    config = ConfigService.by_key_and_section(section, "global")
     limit = config.value if config else 1000
     if current_count > int(limit):
-        log.info('RATE LIMITING: {}: {}, {}'.format(
-            section, resource, current_count))
-        abort_msg = 'Rate limits are in effect for this application'
-        raise HTTPTooManyRequests(abort_msg,
-                                  headers={'X-AppEnlight': abort_msg})
+        log.info("RATE LIMITING: {}: {}, {}".format(section, resource, current_count))
+        abort_msg = "Rate limits are in effect for this application"
+        raise HTTPTooManyRequests(abort_msg, headers={"X-AppEnlight": abort_msg})
 
 
 def check_cors(request, application, should_return=True):
@@ -50,31 +47,34 b' def check_cors(request, application, should_return=True):'
     application, otherwise return 403
     """
     origin_found = False
-    origin = request.headers.get('Origin')
+    origin = request.headers.get("Origin")
     if should_return:
-        log.info('CORS for %s' % origin)
+        log.info("CORS for %s" % origin)
     if not origin:
         return False
-    for domain in application.domains.split('\n'):
+    for domain in application.domains.split("\n"):
         if domain in origin:
             origin_found = True
     if origin_found:
-        request.response.headers.add('Access-Control-Allow-Origin', origin)
-        request.response.headers.add('XDomainRequestAllowed', '1')
-        request.response.headers.add('Access-Control-Allow-Methods',
-                                     'GET, POST, OPTIONS')
-        request.response.headers.add('Access-Control-Allow-Headers',
-                                     'Accept-Encoding, Accept-Language, '
-                                     'Content-Type, '
-                                     'Depth, User-Agent, X-File-Size, '
-                                     'X-Requested-With, If-Modified-Since, '
-                                     'X-File-Name, '
-                                     'Cache-Control, Host, Pragma, Accept, '
-                                     'Origin, Connection, '
-                                     'Referer, Cookie, '
-                                     'X-appenlight-public-api-key, '
-                                     'x-appenlight-public-api-key')
-        request.response.headers.add('Access-Control-Max-Age', '86400')
+        request.response.headers.add("Access-Control-Allow-Origin", origin)
+        request.response.headers.add("XDomainRequestAllowed", "1")
+        request.response.headers.add(
+            "Access-Control-Allow-Methods", "GET, POST, OPTIONS"
+        )
+        request.response.headers.add(
+            "Access-Control-Allow-Headers",
+            "Accept-Encoding, Accept-Language, "
+            "Content-Type, "
+            "Depth, User-Agent, X-File-Size, "
+            "X-Requested-With, If-Modified-Since, "
+            "X-File-Name, "
+            "Cache-Control, Host, Pragma, Accept, "
+            "Origin, Connection, "
+            "Referer, Cookie, "
+            "X-appenlight-public-api-key, "
+            "x-appenlight-public-api-key",
+        )
+        request.response.headers.add("Access-Control-Max-Age", "86400")
         return request.response
     else:
         return HTTPForbidden()

backend/src/appenlight/lib/cache_regions.py

@@ -42,23 +42,27 b' def hashgen(namespace, fn, to_str=compat.string_type):'
     """
 
     if namespace is None:
-        namespace = '%s:%s' % (fn.__module__, fn.__name__)
+        namespace = "%s:%s" % (fn.__module__, fn.__name__)
     else:
-        namespace = '%s:%s|%s' % (fn.__module__, fn.__name__, namespace)
+        namespace = "%s:%s|%s" % (fn.__module__, fn.__name__, namespace)
 
     args = inspect.getargspec(fn)
-    has_self = args[0] and args[0][0] in ('self', 'cls')
+    has_self = args[0] and args[0][0] in ("self", "cls")
 
     def generate_key(*args, **kw):
         if kw:
             raise ValueError(
                 "dogpile.cache's default key creation "
-                "function does not accept keyword arguments.")
+                "function does not accept keyword arguments."
+            )
         if has_self:
             args = args[1:]
 
-        return namespace + "|" + hashlib.sha1(
-            " ".join(map(to_str, args)).encode('utf8')).hexdigest()
+        return (
+            namespace
+            + "|"
+            + hashlib.sha1(" ".join(map(to_str, args)).encode("utf8")).hexdigest()
+        )
 
     return generate_key
 
@@ -68,116 +72,97 b' class CacheRegions(object):'
         config_redis = {"arguments": settings}
 
         self.redis_min_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=60,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=60, **copy.deepcopy(config_redis)
+        )
         self.redis_min_5 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=300,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=300, **copy.deepcopy(config_redis)
+        )
 
         self.redis_min_10 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=60,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=60, **copy.deepcopy(config_redis)
+        )
 
         self.redis_min_60 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=3600,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=3600, **copy.deepcopy(config_redis)
+        )
 
         self.redis_sec_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=1,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=1, **copy.deepcopy(config_redis)
+        )
 
         self.redis_sec_5 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=5,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=5, **copy.deepcopy(config_redis)
+        )
 
         self.redis_sec_30 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=30,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=30, **copy.deepcopy(config_redis)
+        )
 
         self.redis_day_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.redis",
-            expiration_time=86400,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.redis", expiration_time=86400, **copy.deepcopy(config_redis)
+        )
 
         self.redis_day_7 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
             "dogpile.cache.redis",
             expiration_time=86400 * 7,
-            **copy.deepcopy(config_redis))
+            **copy.deepcopy(config_redis)
+        )
 
         self.redis_day_30 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
             "dogpile.cache.redis",
             expiration_time=86400 * 30,
-            **copy.deepcopy(config_redis))
+            **copy.deepcopy(config_redis)
+        )
 
         self.memory_day_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=86400,
-            **copy.deepcopy(config_redis))
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure(
+            "dogpile.cache.memory", expiration_time=86400, **copy.deepcopy(config_redis)
+        )
 
         self.memory_sec_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=1)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=1)
 
         self.memory_sec_5 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=5)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=5)
 
         self.memory_min_1 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=60)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=60)
 
         self.memory_min_5 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=300)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=300)
 
         self.memory_min_10 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=600)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=600)
 
         self.memory_min_60 = make_region(
-            function_key_generator=hashgen,
-            key_mangler=key_mangler).configure(
-            "dogpile.cache.memory",
-            expiration_time=3600)
+            function_key_generator=hashgen, key_mangler=key_mangler
+        ).configure("dogpile.cache.memory", expiration_time=3600)
 
 
 def get_region(region):

backend/src/appenlight/lib/configurator.py

@@ -5,6 +5,7 b' from pyramid.config import Configurator'
 
 log = logging.getLogger(__name__)
 
+
 class InspectProxy(object):
     """
     Proxy to the `inspect` module that allows us to use the pyramid include
@@ -17,7 +18,7 b' class InspectProxy(object):'
         """
         if inspect.ismethod(cyfunction):
             cyfunction = cyfunction.im_func
-        return getattr(cyfunction, 'func_code')
+        return getattr(cyfunction, "func_code")
 
     def getmodule(self, *args, **kwds):
         """
@@ -40,14 +41,14 b' class InspectProxy(object):'
         """
         # Check if it's called to look up the source file that contains the
         # magic pyramid `includeme` callable.
-        if getattr(obj, '__name__') == 'includeme':
+        if getattr(obj, "__name__") == "includeme":
             try:
                 return inspect.getfile(obj)
             except TypeError as e:
                 # Cython functions are not recognized as functions by the
                 # inspect module. We have to unpack the func_code attribute
                 # ourself.
-                if 'cyfunction' in e.message:
+                if "cyfunction" in e.message:
                     obj = self._get_cyfunction_func_code(obj)
                     return inspect.getfile(obj)
                 raise
@@ -60,33 +61,32 b' class CythonCompatConfigurator(Configurator):'
     Customized configurator to replace the inspect class attribute with
     a custom one that is cython compatible.
     """
+
     inspect = InspectProxy()
 
 
 def register_appenlight_plugin(config, plugin_name, plugin_config):
     def register():
-        log.warning('Registering plugin: {}'.format(plugin_name))
+        log.warning("Registering plugin: {}".format(plugin_name))
         if plugin_name not in config.registry.appenlight_plugins:
             config.registry.appenlight_plugins[plugin_name] = {
-                'javascript': None,
-                'static': None,
-                'css': None,
-                'celery_tasks': None,
-                'celery_beats': None,
-                'fulltext_indexer': None,
-                'sqlalchemy_migrations': None,
-                'default_values_setter': None,
-                'header_html': None,
-                'resource_types': [],
-                'url_gen': None
+                "javascript": None,
+                "static": None,
+                "css": None,
+                "celery_tasks": None,
+                "celery_beats": None,
+                "fulltext_indexer": None,
+                "sqlalchemy_migrations": None,
+                "default_values_setter": None,
+                "header_html": None,
+                "resource_types": [],
+                "url_gen": None,
             }
-        config.registry.appenlight_plugins[plugin_name].update(
-            plugin_config)
+        config.registry.appenlight_plugins[plugin_name].update(plugin_config)
         # inform AE what kind of resource types we have available
         # so we can avoid failing when a plugin is removed but data
         # is still present in the db
-        if plugin_config.get('resource_types'):
-            config.registry.resource_types.extend(
-                plugin_config['resource_types'])
+        if plugin_config.get("resource_types"):
+            config.registry.resource_types.extend(plugin_config["resource_types"])
 
-    config.action('appenlight_plugin={}'.format(plugin_name), register)
+    config.action("appenlight_plugin={}".format(plugin_name), register)

backend/src/appenlight/lib/encryption.py

@@ -23,20 +23,20 b' ENCRYPTION_SECRET = None'
 def encrypt_fernet(value):
     # avoid double encryption
     # not sure if this is needed but it won't hurt too much to have this
-    if value.startswith('enc$fernet$'):
+    if value.startswith("enc$fernet$"):
         return value
     f = Fernet(ENCRYPTION_SECRET)
-    return 'enc$fernet${}'.format(f.encrypt(value.encode('utf8')).decode('utf8'))
+    return "enc$fernet${}".format(f.encrypt(value.encode("utf8")).decode("utf8"))
 
 
 def decrypt_fernet(value):
-    parts = value.split('$', 3)
+    parts = value.split("$", 3)
     if not len(parts) == 3:
         # not encrypted values
         return value
     else:
         f = Fernet(ENCRYPTION_SECRET)
-        decrypted_data = f.decrypt(parts[2].encode('utf8')).decode('utf8')
+        decrypted_data = f.decrypt(parts[2].encode("utf8")).decode("utf8")
         return decrypted_data
 
 

backend/src/appenlight/lib/enums.py

@@ -1,4 +1,5 b''
 import collections
+
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
@@ -20,13 +21,14 b' class StupidEnum(object):'
     @classmethod
     def set_inverse(cls):
         cls._inverse_values = dict(
-            (y, x) for x, y in vars(cls).items() if
-            not x.startswith('_') and not callable(y)
+            (y, x)
+            for x, y in vars(cls).items()
+            if not x.startswith("_") and not callable(y)
         )
 
     @classmethod
     def key_from_value(cls, value):
-        if not hasattr(cls, '_inverse_values'):
+        if not hasattr(cls, "_inverse_values"):
             cls.set_inverse()
         return cls._inverse_values.get(value)
 

backend/src/appenlight/lib/ext_json.py

@@ -25,7 +25,7 b' import functools'
 import decimal
 import imp
 
-__all__ = ['json', 'simplejson', 'stdlibjson']
+__all__ = ["json", "simplejson", "stdlibjson"]
 
 
 def _is_aware(value):
@@ -35,8 +35,7 b' def _is_aware(value):'
     The logic is described in Python's docs:
     http://docs.python.org/library/datetime.html#datetime.tzinfo
     """
-    return (value.tzinfo is not None
-            and value.tzinfo.utcoffset(value) is not None)
+    return value.tzinfo is not None and value.tzinfo.utcoffset(value) is not None
 
 
 def _obj_dump(obj):
@@ -55,8 +54,8 b' def _obj_dump(obj):'
         r = obj.isoformat()
         # if obj.microsecond:
         #     r = r[:23] + r[26:]
-        if r.endswith('+00:00'):
-            r = r[:-6] + 'Z'
+        if r.endswith("+00:00"):
+            r = r[:-6] + "Z"
         return r
     elif isinstance(obj, datetime.date):
         return obj.isoformat()
@@ -71,7 +70,7 b' def _obj_dump(obj):'
         return r
     elif isinstance(obj, set):
         return list(obj)
-    elif hasattr(obj, '__json__'):
+    elif hasattr(obj, "__json__"):
         if callable(obj.__json__):
             return obj.__json__()
         else:
@@ -83,8 +82,7 b' def _obj_dump(obj):'
 # Import simplejson
 try:
     # import simplejson initially
-    _sj = imp.load_module('_sj', *imp.find_module('simplejson'))
-
+    _sj = imp.load_module("_sj", *imp.find_module("simplejson"))
 
     def extended_encode(obj):
         try:
@@ -93,22 +91,21 b' try:'
             pass
         raise TypeError("%r is not JSON serializable" % (obj,))
 
-
     # we handle decimals our own it makes unified behavior of json vs
     # simplejson
-    sj_version = [int(x) for x in _sj.__version__.split('.')]
+    sj_version = [int(x) for x in _sj.__version__.split(".")]
     major, minor = sj_version[0], sj_version[1]
     if major < 2 or (major == 2 and minor < 1):
         # simplejson < 2.1 doesnt support use_decimal
-        _sj.dumps = functools.partial(
-            _sj.dumps, default=extended_encode)
-        _sj.dump = functools.partial(
-            _sj.dump, default=extended_encode)
+        _sj.dumps = functools.partial(_sj.dumps, default=extended_encode)
+        _sj.dump = functools.partial(_sj.dump, default=extended_encode)
     else:
         _sj.dumps = functools.partial(
-            _sj.dumps, default=extended_encode, use_decimal=False)
+            _sj.dumps, default=extended_encode, use_decimal=False
+        )
         _sj.dump = functools.partial(
-            _sj.dump, default=extended_encode, use_decimal=False)
+            _sj.dump, default=extended_encode, use_decimal=False
+        )
     simplejson = _sj
 
 except ImportError:
@@ -117,8 +114,7 b' except ImportError:'
 
 try:
     # simplejson not found try out regular json module
-    _json = imp.load_module('_json', *imp.find_module('json'))
-
+    _json = imp.load_module("_json", *imp.find_module("json"))
 
     # extended JSON encoder for json
     class ExtendedEncoder(_json.JSONEncoder):
@@ -129,7 +125,6 b' try:'
                 pass
             raise TypeError("%r is not JSON serializable" % (obj,))
 
-
     # monkey-patch JSON encoder to use extended version
     _json.dumps = functools.partial(_json.dumps, cls=ExtendedEncoder)
     _json.dump = functools.partial(_json.dump, cls=ExtendedEncoder)
@@ -145,4 +140,4 b' if simplejson:'
 elif _json:
     json = _json
 else:
-    raise ImportError('Could not find any json modules')
+    raise ImportError("Could not find any json modules")

backend/src/appenlight/lib/helpers.py

@@ -26,94 +26,135 b' _ = lambda x: x'
 
 time_deltas = OrderedDict()
 
-time_deltas['1m'] = {'delta': datetime.timedelta(minutes=1),
-                     'label': '1 minute', 'minutes': 1}
-
-time_deltas['5m'] = {'delta': datetime.timedelta(minutes=5),
-                     'label': '5 minutes', 'minutes': 5}
-time_deltas['30m'] = {'delta': datetime.timedelta(minutes=30),
-                      'label': '30 minutes', 'minutes': 30}
-time_deltas['1h'] = {'delta': datetime.timedelta(hours=1),
-                     'label': '60 minutes', 'minutes': 60}
-time_deltas['4h'] = {'delta': datetime.timedelta(hours=4), 'label': '4 hours',
-                     'minutes': 60 * 4}
-time_deltas['12h'] = {'delta': datetime.timedelta(hours=12),
-                      'label': '12 hours', 'minutes': 60 * 12}
-time_deltas['24h'] = {'delta': datetime.timedelta(hours=24),
-                      'label': '24 hours', 'minutes': 60 * 24}
-time_deltas['3d'] = {'delta': datetime.timedelta(days=3), 'label': '3 days',
-                     'minutes': 60 * 24 * 3}
-time_deltas['1w'] = {'delta': datetime.timedelta(days=7), 'label': '7 days',
-                     'minutes': 60 * 24 * 7}
-time_deltas['2w'] = {'delta': datetime.timedelta(days=14), 'label': '14 days',
-                     'minutes': 60 * 24 * 14}
-time_deltas['1M'] = {'delta': datetime.timedelta(days=31), 'label': '31 days',
-                     'minutes': 60 * 24 * 31}
-time_deltas['3M'] = {'delta': datetime.timedelta(days=31 * 3),
-                     'label': '3 months',
-                     'minutes': 60 * 24 * 31 * 3}
-time_deltas['6M'] = {'delta': datetime.timedelta(days=31 * 6),
-                     'label': '6 months',
-                     'minutes': 60 * 24 * 31 * 6}
-time_deltas['12M'] = {'delta': datetime.timedelta(days=31 * 12),
-                      'label': '12 months',
-                      'minutes': 60 * 24 * 31 * 12}
+time_deltas["1m"] = {
+    "delta": datetime.timedelta(minutes=1),
+    "label": "1 minute",
+    "minutes": 1,
+}
+
+time_deltas["5m"] = {
+    "delta": datetime.timedelta(minutes=5),
+    "label": "5 minutes",
+    "minutes": 5,
+}
+time_deltas["30m"] = {
+    "delta": datetime.timedelta(minutes=30),
+    "label": "30 minutes",
+    "minutes": 30,
+}
+time_deltas["1h"] = {
+    "delta": datetime.timedelta(hours=1),
+    "label": "60 minutes",
+    "minutes": 60,
+}
+time_deltas["4h"] = {
+    "delta": datetime.timedelta(hours=4),
+    "label": "4 hours",
+    "minutes": 60 * 4,
+}
+time_deltas["12h"] = {
+    "delta": datetime.timedelta(hours=12),
+    "label": "12 hours",
+    "minutes": 60 * 12,
+}
+time_deltas["24h"] = {
+    "delta": datetime.timedelta(hours=24),
+    "label": "24 hours",
+    "minutes": 60 * 24,
+}
+time_deltas["3d"] = {
+    "delta": datetime.timedelta(days=3),
+    "label": "3 days",
+    "minutes": 60 * 24 * 3,
+}
+time_deltas["1w"] = {
+    "delta": datetime.timedelta(days=7),
+    "label": "7 days",
+    "minutes": 60 * 24 * 7,
+}
+time_deltas["2w"] = {
+    "delta": datetime.timedelta(days=14),
+    "label": "14 days",
+    "minutes": 60 * 24 * 14,
+}
+time_deltas["1M"] = {
+    "delta": datetime.timedelta(days=31),
+    "label": "31 days",
+    "minutes": 60 * 24 * 31,
+}
+time_deltas["3M"] = {
+    "delta": datetime.timedelta(days=31 * 3),
+    "label": "3 months",
+    "minutes": 60 * 24 * 31 * 3,
+}
+time_deltas["6M"] = {
+    "delta": datetime.timedelta(days=31 * 6),
+    "label": "6 months",
+    "minutes": 60 * 24 * 31 * 6,
+}
+time_deltas["12M"] = {
+    "delta": datetime.timedelta(days=31 * 12),
+    "label": "12 months",
+    "minutes": 60 * 24 * 31 * 12,
+}
 
 # used in json representation
-time_options = dict([(k, {'label': v['label'], 'minutes': v['minutes']})
-                     for k, v in time_deltas.items()])
-FlashMsg = namedtuple('FlashMsg', ['msg', 'level'])
+time_options = dict(
+    [
+        (k, {"label": v["label"], "minutes": v["minutes"]})
+        for k, v in time_deltas.items()
+    ]
+)
+FlashMsg = namedtuple("FlashMsg", ["msg", "level"])
 
 
 def get_flash(request):
     messages = []
     messages.extend(
-        [FlashMsg(msg, 'error')
-         for msg in request.session.peek_flash('error')])
-    messages.extend([FlashMsg(msg, 'warning')
-                     for msg in request.session.peek_flash('warning')])
+        [FlashMsg(msg, "error") for msg in request.session.peek_flash("error")]
+    )
     messages.extend(
-        [FlashMsg(msg, 'notice') for msg in request.session.peek_flash()])
+        [FlashMsg(msg, "warning") for msg in request.session.peek_flash("warning")]
+    )
+    messages.extend([FlashMsg(msg, "notice") for msg in request.session.peek_flash()])
     return messages
 
 
 def clear_flash(request):
-    request.session.pop_flash('error')
-    request.session.pop_flash('warning')
+    request.session.pop_flash("error")
+    request.session.pop_flash("warning")
     request.session.pop_flash()
 
 
 def get_type_formatted_flash(request):
-    return [{'msg': message.msg, 'type': message.level}
-            for message in get_flash(request)]
+    return [
+        {"msg": message.msg, "type": message.level} for message in get_flash(request)
+    ]
 
 
 def gen_pagination_headers(request, paginator):
     headers = {
-        'x-total-count': str(paginator.item_count),
-        'x-current-page': str(paginator.page),
-        'x-items-per-page': str(paginator.items_per_page)
+        "x-total-count": str(paginator.item_count),
+        "x-current-page": str(paginator.page),
+        "x-items-per-page": str(paginator.items_per_page),
     }
     params_dict = request.GET.dict_of_lists()
     last_page_params = copy.deepcopy(params_dict)
-    last_page_params['page'] = paginator.last_page or 1
+    last_page_params["page"] = paginator.last_page or 1
     first_page_params = copy.deepcopy(params_dict)
-    first_page_params.pop('page', None)
+    first_page_params.pop("page", None)
     next_page_params = copy.deepcopy(params_dict)
-    next_page_params['page'] = paginator.next_page or paginator.last_page or 1
+    next_page_params["page"] = paginator.next_page or paginator.last_page or 1
     prev_page_params = copy.deepcopy(params_dict)
-    prev_page_params['page'] = paginator.previous_page or 1
+    prev_page_params["page"] = paginator.previous_page or 1
     lp_url = request.current_route_url(_query=last_page_params)
     fp_url = request.current_route_url(_query=first_page_params)
-    links = [
-        'rel="last", <{}>'.format(lp_url),
-        'rel="first", <{}>'.format(fp_url),
-    ]
+    links = ['rel="last", <{}>'.format(lp_url), 'rel="first", <{}>'.format(fp_url)]
     if first_page_params != prev_page_params:
         prev_url = request.current_route_url(_query=prev_page_params)
         links.append('rel="prev", <{}>'.format(prev_url))
     if last_page_params != next_page_params:
         next_url = request.current_route_url(_query=next_page_params)
         links.append('rel="next", <{}>'.format(next_url))
-    headers['link'] = '; '.join(links)
+    headers["link"] = "; ".join(links)
     return headers

backend/src/appenlight/lib/jinja2_filters.py

@@ -18,17 +18,21 b' import re'
 from appenlight.lib.ext_json import json
 from jinja2 import Markup, escape, evalcontextfilter
 
-_paragraph_re = re.compile(r'(?:\r\n|\r|\n){2,}')
+_paragraph_re = re.compile(r"(?:\r\n|\r|\n){2,}")
 
 
 @evalcontextfilter
 def nl2br(eval_ctx, value):
     if eval_ctx.autoescape:
-        result = '\n\n'.join('<p>%s</p>' % p.replace('\n', Markup('<br>\n'))
-                              for p in _paragraph_re.split(escape(value)))
+        result = "\n\n".join(
+            "<p>%s</p>" % p.replace("\n", Markup("<br>\n"))
+            for p in _paragraph_re.split(escape(value))
+        )
     else:
-        result = '\n\n'.join('<p>%s</p>' % p.replace('\n', '<br>\n')
-                              for p in _paragraph_re.split(escape(value)))
+        result = "\n\n".join(
+            "<p>%s</p>" % p.replace("\n", "<br>\n")
+            for p in _paragraph_re.split(escape(value))
+        )
     if eval_ctx.autoescape:
         result = Markup(result)
     return result
@@ -36,11 +40,14 b' def nl2br(eval_ctx, value):'
 
 @evalcontextfilter
 def toJSONUnsafe(eval_ctx, value):
-    encoded = json.dumps(value).replace('&', '\\u0026') \
-        .replace('<', '\\u003c') \
-        .replace('>', '\\u003e') \
-        .replace('>', '\\u003e') \
-        .replace('"', '\\u0022') \
-        .replace("'", '\\u0027') \
-        .replace(r'\n', '/\\\n')
+    encoded = (
+        json.dumps(value)
+        .replace("&", "\\u0026")
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace(">", "\\u003e")
+        .replace('"', "\\u0022")
+        .replace("'", "\\u0027")
+        .replace(r"\n", "/\\\n")
+    )
     return Markup("'%s'" % encoded)

backend/src/appenlight/lib/logging.py

@@ -17,11 +17,30 b''
 import json
 import logging
 
-ignored_keys = ['args', 'asctime', 'created', 'exc_info', 'exc_text',
-                'filename', 'funcName', 'levelname', 'levelno', 'lineno',
-                'message', 'module', 'msecs', 'msg', 'name', 'pathname',
-                'process', 'processName', 'relativeCreated', 'stack_info',
-                'thread', 'threadName']
+ignored_keys = [
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "message",
+    "module",
+    "msecs",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+]
 
 
 class JSONFormatter(logging.Formatter):
@@ -41,7 +60,7 b' class JSONFormatter(logging.Formatter):'
         record.message = record.getMessage()
         log_dict = vars(record)
         keys = [k for k in log_dict.keys() if k not in ignored_keys]
-        payload = {'message': record.message}
+        payload = {"message": record.message}
         payload.update({k: log_dict[k] for k in keys})
         record.message = json.dumps(payload, default=lambda x: str(x))
 

backend/src/appenlight/lib/redis_keys.py

@@ -14,52 +14,56 b''
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-BASE = 'appenlight:data:{}'
+BASE = "appenlight:data:{}"
 
 REDIS_KEYS = {
-    'tasks': {
-        'add_reports_lock': BASE.format('add_reports_lock:{}'),
-        'add_logs_lock': BASE.format('add_logs_lock:{}'),
+    "tasks": {
+        "add_reports_lock": BASE.format("add_reports_lock:{}"),
+        "add_logs_lock": BASE.format("add_logs_lock:{}"),
     },
-    'counters': {
-        'events_per_minute_per_user': BASE.format(
-            'events_per_minute_per_user:{}:{}'),
-        'reports_per_minute': BASE.format('reports_per_minute:{}'),
-        'reports_per_hour_per_app': BASE.format(
-            'reports_per_hour_per_app:{}:{}'),
-        'reports_per_type': BASE.format('reports_per_type:{}'),
-        'logs_per_minute': BASE.format('logs_per_minute:{}'),
-        'logs_per_hour_per_app': BASE.format(
-            'logs_per_hour_per_app:{}:{}'),
-        'metrics_per_minute': BASE.format('metrics_per_minute:{}'),
-        'metrics_per_hour_per_app': BASE.format(
-            'metrics_per_hour_per_app:{}:{}'),
-        'report_group_occurences': BASE.format('report_group_occurences:{}'),
-        'report_group_occurences_alerting': BASE.format(
-            'report_group_occurences_alerting:{}'),
-        'report_group_occurences_10th': BASE.format(
-            'report_group_occurences_10th:{}'),
-        'report_group_occurences_100th': BASE.format(
-            'report_group_occurences_100th:{}'),
+    "counters": {
+        "events_per_minute_per_user": BASE.format("events_per_minute_per_user:{}:{}"),
+        "reports_per_minute": BASE.format("reports_per_minute:{}"),
+        "reports_per_hour_per_app": BASE.format("reports_per_hour_per_app:{}:{}"),
+        "reports_per_type": BASE.format("reports_per_type:{}"),
+        "logs_per_minute": BASE.format("logs_per_minute:{}"),
+        "logs_per_hour_per_app": BASE.format("logs_per_hour_per_app:{}:{}"),
+        "metrics_per_minute": BASE.format("metrics_per_minute:{}"),
+        "metrics_per_hour_per_app": BASE.format("metrics_per_hour_per_app:{}:{}"),
+        "report_group_occurences": BASE.format("report_group_occurences:{}"),
+        "report_group_occurences_alerting": BASE.format(
+            "report_group_occurences_alerting:{}"
+        ),
+        "report_group_occurences_10th": BASE.format("report_group_occurences_10th:{}"),
+        "report_group_occurences_100th": BASE.format(
+            "report_group_occurences_100th:{}"
+        ),
     },
-    'rate_limits': {
-        'per_application_reports_rate_limit': BASE.format(
-            'per_application_reports_limit:{}:{}'),
-        'per_application_logs_rate_limit': BASE.format(
-            'per_application_logs_rate_limit:{}:{}'),
-        'per_application_metrics_rate_limit': BASE.format(
-            'per_application_metrics_rate_limit:{}:{}'),
+    "rate_limits": {
+        "per_application_reports_rate_limit": BASE.format(
+            "per_application_reports_limit:{}:{}"
+        ),
+        "per_application_logs_rate_limit": BASE.format(
+            "per_application_logs_rate_limit:{}:{}"
+        ),
+        "per_application_metrics_rate_limit": BASE.format(
+            "per_application_metrics_rate_limit:{}:{}"
+        ),
     },
-    'apps_that_got_new_data_per_hour': BASE.format('apps_that_got_new_data_per_hour:{}'),
-    'apps_that_had_reports': BASE.format('apps_that_had_reports'),
-    'apps_that_had_error_reports': BASE.format('apps_that_had_error_reports'),
-    'apps_that_had_reports_alerting': BASE.format(
-        'apps_that_had_reports_alerting'),
-    'apps_that_had_error_reports_alerting': BASE.format(
-        'apps_that_had_error_reports_alerting'),
-    'reports_to_notify_per_type_per_app': BASE.format(
-        'reports_to_notify_per_type_per_app:{}:{}'),
-    'reports_to_notify_per_type_per_app_alerting': BASE.format(
-        'reports_to_notify_per_type_per_app_alerting:{}:{}'),
-    'seen_tag_list': BASE.format('seen_tag_list')
+    "apps_that_got_new_data_per_hour": BASE.format(
+        "apps_that_got_new_data_per_hour:{}"
+    ),
+    "apps_that_had_reports": BASE.format("apps_that_had_reports"),
+    "apps_that_had_error_reports": BASE.format("apps_that_had_error_reports"),
+    "apps_that_had_reports_alerting": BASE.format("apps_that_had_reports_alerting"),
+    "apps_that_had_error_reports_alerting": BASE.format(
+        "apps_that_had_error_reports_alerting"
+    ),
+    "reports_to_notify_per_type_per_app": BASE.format(
+        "reports_to_notify_per_type_per_app:{}:{}"
+    ),
+    "reports_to_notify_per_type_per_app_alerting": BASE.format(
+        "reports_to_notify_per_type_per_app_alerting:{}:{}"
+    ),
+    "seen_tag_list": BASE.format("seen_tag_list"),
 }

backend/src/appenlight/lib/request.py

@@ -54,11 +54,11 b' def unsafe_json_body(request):'
     try:
         return request.json_body
     except ValueError:
-        raise JSONException('Incorrect JSON')
+        raise JSONException("Incorrect JSON")
 
 
 def get_user(request):
-    if not request.path_info.startswith('/static'):
+    if not request.path_info.startswith("/static"):
         user_id = unauthenticated_userid(request)
         try:
             user_id = int(user_id)
@@ -68,8 +68,10 b' def get_user(request):'
         if user_id:
             user = UserService.by_id(user_id)
             if user:
-                request.environ['appenlight.username'] = '%d:%s' % (
-                    user_id, user.user_name)
+                request.environ["appenlight.username"] = "%d:%s" % (
+                    user_id,
+                    user.user_name,
+                )
             return user
         else:
             return None
@@ -85,7 +87,7 b' def add_flash_to_headers(request, clear=True):'
     flash queue
     """
     flash_msgs = helpers.get_type_formatted_flash(request)
-    request.response.headers['x-flash-messages'] = json.dumps(flash_msgs)
+    request.response.headers["x-flash-messages"] = json.dumps(flash_msgs)
     helpers.clear_flash(request)
 
 
@@ -94,42 +96,36 b' def get_authomatic(request):'
     # authomatic social auth
     authomatic_conf = {
         # callback http://yourapp.com/social_auth/twitter
-        'twitter': {
-            'class_': oauth1.Twitter,
-            'consumer_key': settings.get('authomatic.pr.twitter.key', ''),
-            'consumer_secret': settings.get('authomatic.pr.twitter.secret',
-                                            ''),
+        "twitter": {
+            "class_": oauth1.Twitter,
+            "consumer_key": settings.get("authomatic.pr.twitter.key", ""),
+            "consumer_secret": settings.get("authomatic.pr.twitter.secret", ""),
         },
         # callback http://yourapp.com/social_auth/facebook
-        'facebook': {
-            'class_': oauth2.Facebook,
-            'consumer_key': settings.get('authomatic.pr.facebook.app_id', ''),
-            'consumer_secret': settings.get('authomatic.pr.facebook.secret',
-                                            ''),
-            'scope': ['email'],
+        "facebook": {
+            "class_": oauth2.Facebook,
+            "consumer_key": settings.get("authomatic.pr.facebook.app_id", ""),
+            "consumer_secret": settings.get("authomatic.pr.facebook.secret", ""),
+            "scope": ["email"],
         },
         # callback http://yourapp.com/social_auth/google
-        'google': {
-            'class_': oauth2.Google,
-            'consumer_key': settings.get('authomatic.pr.google.key', ''),
-            'consumer_secret': settings.get(
-                'authomatic.pr.google.secret', ''),
-            'scope': ['profile', 'email'],
+        "google": {
+            "class_": oauth2.Google,
+            "consumer_key": settings.get("authomatic.pr.google.key", ""),
+            "consumer_secret": settings.get("authomatic.pr.google.secret", ""),
+            "scope": ["profile", "email"],
         },
-        'github': {
-            'class_': oauth2.GitHub,
-            'consumer_key': settings.get('authomatic.pr.github.key', ''),
-            'consumer_secret': settings.get(
-                'authomatic.pr.github.secret', ''),
-            'scope': ['repo', 'public_repo', 'user:email'],
-            'access_headers': {'User-Agent': 'AppEnlight'},
+        "github": {
+            "class_": oauth2.GitHub,
+            "consumer_key": settings.get("authomatic.pr.github.key", ""),
+            "consumer_secret": settings.get("authomatic.pr.github.secret", ""),
+            "scope": ["repo", "public_repo", "user:email"],
+            "access_headers": {"User-Agent": "AppEnlight"},
+        },
+        "bitbucket": {
+            "class_": oauth1.Bitbucket,
+            "consumer_key": settings.get("authomatic.pr.bitbucket.key", ""),
+            "consumer_secret": settings.get("authomatic.pr.bitbucket.secret", ""),
         },
-        'bitbucket': {
-            'class_': oauth1.Bitbucket,
-            'consumer_key': settings.get('authomatic.pr.bitbucket.key', ''),
-            'consumer_secret': settings.get(
-                'authomatic.pr.bitbucket.secret', '')
-        }
     }
-    return Authomatic(
-        config=authomatic_conf, secret=settings['authomatic.secret'])
+    return Authomatic(config=authomatic_conf, secret=settings["authomatic.secret"])

backend/src/appenlight/lib/rule.py

@@ -52,13 +52,13 b' class RuleBase(object):'
         :param field_name:
         :return:
         """
-        parts = field_name.split(':') if field_name else []
+        parts = field_name.split(":") if field_name else []
         found = struct
         while parts:
             current_key = parts.pop(0)
             found = found.get(current_key)
             if not found and parts:
-                raise KeyNotFoundException('Key not found in structure')
+                raise KeyNotFoundException("Key not found in structure")
         return found
 
     @classmethod
@@ -72,13 +72,13 b' class RuleBase(object):'
         :param field_name:
         :return:
         """
-        parts = field_name.split(':')
+        parts = field_name.split(":")
         found = struct
         while parts:
             current_key = parts.pop(0)
             found = getattr(found, current_key, None)
             if not found and parts:
-                raise KeyNotFoundException('Key not found in structure')
+                raise KeyNotFoundException("Key not found in structure")
         return found
 
     def normalized_type(self, field, value):
@@ -89,28 +89,32 b' class RuleBase(object):'
         """
         f_type = self.type_matrix.get(field)
         if f_type:
-            cast_to = f_type['type']
+            cast_to = f_type["type"]
         else:
-            raise UnknownTypeException('Unknown type')
+            raise UnknownTypeException("Unknown type")
 
         if value is None:
             return None
 
         try:
-            if cast_to == 'int':
+            if cast_to == "int":
                 return int(value)
-            elif cast_to == 'float':
+            elif cast_to == "float":
                 return float(value)
-            elif cast_to == 'unicode':
+            elif cast_to == "unicode":
                 return str(value)
         except ValueError as exc:
             raise InvalidValueException(exc)
 
 
 class Rule(RuleBase):
-    def __init__(self, config, type_matrix,
+    def __init__(
+        self,
+        config,
+        type_matrix,
                  struct_getter=RuleBase.default_dict_struct_getter,
-                 config_manipulator=None):
+        config_manipulator=None,
+    ):
         """
 
         :param config: dict - contains rule configuration
@@ -159,8 +163,9 b' class Rule(RuleBase):'
             config_manipulator(self)
 
     def subrule_check(self, rule_config, struct):
-        rule = Rule(rule_config, self.type_matrix,
-                    config_manipulator=self.config_manipulator)
+        rule = Rule(
+            rule_config, self.type_matrix, config_manipulator=self.config_manipulator
+        )
         return rule.match(struct)
 
     def match(self, struct):
@@ -169,32 +174,41 b' class Rule(RuleBase):'
         First tries report value, then tests tags in not found, then finally
         report group
         """
-        field_name = self.config.get('field')
-        test_value = self.config.get('value')
+        field_name = self.config.get("field")
+        test_value = self.config.get("value")
 
         if not field_name:
             return False
 
-        if field_name == '__AND__':
-            rule = AND(self.config['rules'], self.type_matrix,
-                       config_manipulator=self.config_manipulator)
+        if field_name == "__AND__":
+            rule = AND(
+                self.config["rules"],
+                self.type_matrix,
+                config_manipulator=self.config_manipulator,
+            )
             return rule.match(struct)
-        elif field_name == '__OR__':
-            rule = OR(self.config['rules'], self.type_matrix,
-                      config_manipulator=self.config_manipulator)
+        elif field_name == "__OR__":
+            rule = OR(
+                self.config["rules"],
+                self.type_matrix,
+                config_manipulator=self.config_manipulator,
+            )
             return rule.match(struct)
-        elif field_name == '__NOT__':
-            rule = NOT(self.config['rules'], self.type_matrix,
-                      config_manipulator=self.config_manipulator)
+        elif field_name == "__NOT__":
+            rule = NOT(
+                self.config["rules"],
+                self.type_matrix,
+                config_manipulator=self.config_manipulator,
+            )
             return rule.match(struct)
 
         if test_value is None:
             return False
 
         try:
-            struct_value = self.normalized_type(field_name,
-                                                self.struct_getter(struct,
-                                                                   field_name))
+            struct_value = self.normalized_type(
+                field_name, self.struct_getter(struct, field_name)
+            )
         except (UnknownTypeException, InvalidValueException) as exc:
             log.error(str(exc))
             return False
@@ -205,24 +219,23 b' class Rule(RuleBase):'
             log.error(str(exc))
             return False
 
-        if self.config['op'] not in ('startswith', 'endswith', 'contains'):
+        if self.config["op"] not in ("startswith", "endswith", "contains"):
             try:
-                return getattr(operator,
-                               self.config['op'])(struct_value, test_value)
+                return getattr(operator, self.config["op"])(struct_value, test_value)
             except TypeError:
                 return False
-        elif self.config['op'] == 'startswith':
+        elif self.config["op"] == "startswith":
             return struct_value.startswith(test_value)
-        elif self.config['op'] == 'endswith':
+        elif self.config["op"] == "endswith":
             return struct_value.endswith(test_value)
-        elif self.config['op'] == 'contains':
+        elif self.config["op"] == "contains":
             return test_value in struct_value
-        raise BadConfigException('Invalid configuration, '
-                                 'unknown operator: {}'.format(self.config))
+        raise BadConfigException(
+            "Invalid configuration, " "unknown operator: {}".format(self.config)
+        )
 
     def __repr__(self):
-        return '<Rule {} {}>'.format(self.config.get('field'),
-                                     self.config.get('value'))
+        return "<Rule {} {}>".format(self.config.get("field"), self.config.get("value"))
 
 
 class AND(Rule):
@@ -231,8 +244,7 b' class AND(Rule):'
         self.rules = rules
 
     def match(self, struct):
-        return all([self.subrule_check(r_conf, struct) for r_conf
-                    in self.rules])
+        return all([self.subrule_check(r_conf, struct) for r_conf in self.rules])
 
 
 class NOT(Rule):
@@ -241,8 +253,7 b' class NOT(Rule):'
         self.rules = rules
 
     def match(self, struct):
-        return all([not self.subrule_check(r_conf, struct) for r_conf
-                    in self.rules])
+        return all([not self.subrule_check(r_conf, struct) for r_conf in self.rules])
 
 
 class OR(Rule):
@@ -251,14 +262,12 b' class OR(Rule):'
         self.rules = rules
 
     def match(self, struct):
-        return any([self.subrule_check(r_conf, struct) for r_conf
-                    in self.rules])
+        return any([self.subrule_check(r_conf, struct) for r_conf in self.rules])
 
 
 class RuleService(object):
     @staticmethod
-    def rule_from_config(config, field_mappings, labels_dict,
-                         manipulator_func=None):
+    def rule_from_config(config, field_mappings, labels_dict, manipulator_func=None):
         """
         Returns modified rule with manipulator function
         By default manipulator function replaces field id from labels_dict
@@ -270,28 +279,33 b' class RuleService(object):'
         """
         rev_map = {}
         for k, v in labels_dict.items():
-            rev_map[(v['agg'], v['key'],)] = k
+            rev_map[(v["agg"], v["key"])] = k
 
         if manipulator_func is None:
+
             def label_rewriter_func(rule):
-                field = rule.config.get('field')
-                if not field or rule.config['field'] in ['__OR__',
-                                                         '__AND__', '__NOT__']:
+                field = rule.config.get("field")
+                if not field or rule.config["field"] in [
+                    "__OR__",
+                    "__AND__",
+                    "__NOT__",
+                ]:
                     return
 
-                to_map = field_mappings.get(rule.config['field'])
+                to_map = field_mappings.get(rule.config["field"])
 
                 # we need to replace series field with _AE_NOT_FOUND_ to not match
                 # accidently some other field which happens to have the series that
                 # was used when the alert was created
                 if to_map:
-                    to_replace = rev_map.get((to_map['agg'], to_map['key'],),
-                                             '_AE_NOT_FOUND_')
+                    to_replace = rev_map.get(
+                        (to_map["agg"], to_map["key"]), "_AE_NOT_FOUND_"
+                    )
                 else:
-                    to_replace = '_AE_NOT_FOUND_'
+                    to_replace = "_AE_NOT_FOUND_"
 
-                rule.config['field'] = to_replace
-                rule.type_matrix[to_replace] = {"type": 'float'}
+                rule.config["field"] = to_replace
+                rule.type_matrix[to_replace] = {"type": "float"}
 
             manipulator_func = label_rewriter_func
 

backend/src/appenlight/lib/social.py

@@ -14,8 +14,9 b''
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ziggurat_foundations.models.services.external_identity import \
-    ExternalIdentityService
+from ziggurat_foundations.models.services.external_identity import (
+    ExternalIdentityService,
+)
 from appenlight.models.external_identity import ExternalIdentity
 
 
@@ -24,37 +25,38 b' def handle_social_data(request, user, social_data):'
     update_identity = False
 
     extng_id = ExternalIdentityService.by_external_id_and_provider(
-        social_data['user']['id'],
-        social_data['credentials'].provider_name
+        social_data["user"]["id"], social_data["credentials"].provider_name
     )
 
     # fix legacy accounts with wrong google ID
-    if not extng_id and social_data['credentials'].provider_name == 'google':
+    if not extng_id and social_data["credentials"].provider_name == "google":
         extng_id = ExternalIdentityService.by_external_id_and_provider(
-            social_data['user']['email'],
-            social_data['credentials'].provider_name
+            social_data["user"]["email"], social_data["credentials"].provider_name
         )
 
     if extng_id:
         extng_id.delete()
         update_identity = True
 
-    if not social_data['user']['id']:
+    if not social_data["user"]["id"]:
         request.session.flash(
-            'No external user id found? Perhaps permissions for '
-            'authentication are set incorrectly', 'error')
+            "No external user id found? Perhaps permissions for "
+            "authentication are set incorrectly",
+            "error",
+        )
         return False
 
     if not extng_id or update_identity:
         if not update_identity:
-            request.session.flash('Your external identity is now '
-                                  'connected with your account')
+            request.session.flash(
+                "Your external identity is now " "connected with your account"
+            )
         ex_identity = ExternalIdentity()
-        ex_identity.external_id = social_data['user']['id']
-        ex_identity.external_user_name = social_data['user']['user_name']
-        ex_identity.provider_name = social_data['credentials'].provider_name
-        ex_identity.access_token = social_data['credentials'].token
-        ex_identity.token_secret = social_data['credentials'].token_secret
-        ex_identity.alt_token = social_data['credentials'].refresh_token
+        ex_identity.external_id = social_data["user"]["id"]
+        ex_identity.external_user_name = social_data["user"]["user_name"]
+        ex_identity.provider_name = social_data["credentials"].provider_name
+        ex_identity.access_token = social_data["credentials"].token
+        ex_identity.token_secret = social_data["credentials"].token_secret
+        ex_identity.alt_token = social_data["credentials"].refresh_token
         user.external_identities.append(ex_identity)
-        request.session.pop('zigg.social_auth', None)
+        request.session.pop("zigg.social_auth", None)

backend/src/appenlight/lib/utils/__init__.py

@@ -28,9 +28,7 b' from collections import namedtuple'
 from datetime import timedelta, datetime, date
 from dogpile.cache.api import NO_VALUE
 from appenlight.models import Datastores
-from appenlight.validators import (LogSearchSchema,
-                                   TagListSchema,
-                                   accepted_search_params)
+from appenlight.validators import LogSearchSchema, TagListSchema, accepted_search_params
 from itsdangerous import TimestampSigner
 from ziggurat_foundations.permissions import ALL_PERMISSIONS
 from ziggurat_foundations.models.services.user import UserService
@@ -40,21 +38,20 b' from dateutil.rrule import rrule, MONTHLY, DAILY'
 log = logging.getLogger(__name__)
 
 
-Stat = namedtuple('Stat', 'start_interval value')
+Stat = namedtuple("Stat", "start_interval value")
 
 
 def default_extractor(item):
     """
     :param item - item to extract date from
     """
-    if hasattr(item, 'start_interval'):
+    if hasattr(item, "start_interval"):
         return item.start_interval
-    return item['start_interval']
+    return item["start_interval"]
 
 
 # fast gap generator
-def gap_gen_default(start, step, itemiterator, end_time=None,
-                    iv_extractor=None):
+def gap_gen_default(start, step, itemiterator, end_time=None, iv_extractor=None):
     """ generates a list of time/value items based on step and itemiterator
         if there are entries missing from iterator time/None will be returned
         instead
@@ -100,27 +97,31 b' class DateTimeEncoder(json.JSONEncoder):'
         return json.JSONEncoder.default(self, obj)
 
 
-def channelstream_request(secret, endpoint, payload, throw_exceptions=False,
-                   servers=None):
+def channelstream_request(
+    secret, endpoint, payload, throw_exceptions=False, servers=None
+):
     responses = []
     if not servers:
         servers = []
 
     signer = TimestampSigner(secret)
     sig_for_server = signer.sign(endpoint)
-    for secret, server in [(s['secret'], s['server']) for s in servers]:
+    for secret, server in [(s["secret"], s["server"]) for s in servers]:
         response = {}
-        secret_headers = {'x-channelstream-secret': sig_for_server,
-                          'x-channelstream-endpoint': endpoint,
-                          'Content-Type': 'application/json'}
-        url = '%s%s' % (server, endpoint)
+        secret_headers = {
+            "x-channelstream-secret": sig_for_server,
+            "x-channelstream-endpoint": endpoint,
+            "Content-Type": "application/json",
+        }
+        url = "%s%s" % (server, endpoint)
         try:
-            response = requests.post(url,
-                                     data=json.dumps(payload,
-                                                     cls=DateTimeEncoder),
+            response = requests.post(
+                url,
+                data=json.dumps(payload, cls=DateTimeEncoder),
                                      headers=secret_headers,
                                      verify=False,
-                                     timeout=2).json()
+                timeout=2,
+            ).json()
         except requests.exceptions.RequestException as e:
             if throw_exceptions:
                 raise
@@ -130,13 +131,15 b' def channelstream_request(secret, endpoint, payload, throw_exceptions=False,'
 
 def add_cors_headers(response):
     # allow CORS
-    response.headers.add('Access-Control-Allow-Origin', '*')
-    response.headers.add('XDomainRequestAllowed', '1')
-    response.headers.add('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+    response.headers.add("Access-Control-Allow-Origin", "*")
+    response.headers.add("XDomainRequestAllowed", "1")
+    response.headers.add("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
     # response.headers.add('Access-Control-Allow-Credentials', 'true')
-    response.headers.add('Access-Control-Allow-Headers',
-                         'Content-Type, Depth, User-Agent, X-File-Size, X-Requested-With, If-Modified-Since, X-File-Name, Cache-Control, Pragma, Origin, Connection, Referer, Cookie')
-    response.headers.add('Access-Control-Max-Age', '86400')
+    response.headers.add(
+        "Access-Control-Allow-Headers",
+        "Content-Type, Depth, User-Agent, X-File-Size, X-Requested-With, If-Modified-Since, X-File-Name, Cache-Control, Pragma, Origin, Connection, Referer, Cookie",
+    )
+    response.headers.add("Access-Control-Max-Age", "86400")
 
 
 from sqlalchemy.sql import compiler
@@ -145,6 +148,7 b' from psycopg2.extensions import adapt as sqlescape'
 
 # or use the appropiate escape function from your db driver
 
+
 def compile_query(query):
     dialect = query.session.bind.dialect
     statement = query.statement
@@ -166,22 +170,23 b' def convert_es_type(input_data):'
     return str(input_data)
 
 
-ProtoVersion = namedtuple('ProtoVersion', ['major', 'minor', 'patch'])
+ProtoVersion = namedtuple("ProtoVersion", ["major", "minor", "patch"])
 
 
 def parse_proto(input_data):
     try:
-        parts = [int(x) for x in input_data.split('.')]
+        parts = [int(x) for x in input_data.split(".")]
         while len(parts) < 3:
             parts.append(0)
         return ProtoVersion(*parts)
     except Exception as e:
-        log.info('Unknown protocol version: %s' % e)
+        log.info("Unknown protocol version: %s" % e)
     return ProtoVersion(99, 99, 99)
 
 
-def es_index_name_limiter(start_date=None, end_date=None, months_in_past=6,
-                          ixtypes=None):
+def es_index_name_limiter(
+    start_date=None, end_date=None, months_in_past=6, ixtypes=None
+):
     """
     This function limits the search to 6 months by default so we don't have to
     query 300 elasticsearch indices for 20 years of historical data for example
@@ -189,23 +194,23 b' def es_index_name_limiter(start_date=None, end_date=None, months_in_past=6,'
 
     # should be cached later
     def get_possible_names():
-        return list(Datastores.es.indices.get_alias('*'))
+        return list(Datastores.es.indices.get_alias("*"))
 
     possible_names = get_possible_names()
     es_index_types = []
     if not ixtypes:
-        ixtypes = ['reports', 'metrics', 'logs']
+        ixtypes = ["reports", "metrics", "logs"]
     for t in ixtypes:
-        if t == 'reports':
-            es_index_types.append('rcae_r_%s')
-        elif t == 'logs':
-            es_index_types.append('rcae_l_%s')
-        elif t == 'metrics':
-            es_index_types.append('rcae_m_%s')
-        elif t == 'uptime':
-            es_index_types.append('rcae_u_%s')
-        elif t == 'slow_calls':
-            es_index_types.append('rcae_sc_%s')
+        if t == "reports":
+            es_index_types.append("rcae_r_%s")
+        elif t == "logs":
+            es_index_types.append("rcae_l_%s")
+        elif t == "metrics":
+            es_index_types.append("rcae_m_%s")
+        elif t == "uptime":
+            es_index_types.append("rcae_u_%s")
+        elif t == "slow_calls":
+            es_index_types.append("rcae_sc_%s")
 
     if start_date:
         start_date = copy.copy(start_date)
@@ -217,26 +222,34 b' def es_index_name_limiter(start_date=None, end_date=None, months_in_past=6,'
     if not end_date:
         end_date = start_date + relativedelta(months=months_in_past)
 
-    index_dates = list(rrule(MONTHLY,
+    index_dates = list(
+        rrule(
+            MONTHLY,
                              dtstart=start_date.date().replace(day=1),
                              until=end_date.date(),
-                             count=36))
+            count=36,
+        )
+    )
     index_names = []
     for ix_type in es_index_types:
-        to_extend = [ix_type % d.strftime('%Y_%m') for d in index_dates
-                     if ix_type % d.strftime('%Y_%m') in possible_names]
+        to_extend = [
+            ix_type % d.strftime("%Y_%m")
+            for d in index_dates
+            if ix_type % d.strftime("%Y_%m") in possible_names
+        ]
         index_names.extend(to_extend)
-        for day in list(rrule(DAILY, dtstart=start_date.date(),
-                              until=end_date.date(), count=366)):
-            ix_name = ix_type % day.strftime('%Y_%m_%d')
+        for day in list(
+            rrule(DAILY, dtstart=start_date.date(), until=end_date.date(), count=366)
+        ):
+            ix_name = ix_type % day.strftime("%Y_%m_%d")
             if ix_name in possible_names:
                 index_names.append(ix_name)
     return index_names
 
 
 def build_filter_settings_from_query_dict(
-        request, params=None, override_app_ids=None,
-        resource_permissions=None):
+    request, params=None, override_app_ids=None, resource_permissions=None
+):
     """
     Builds list of normalized search terms for ES from query params
     ensuring application list is restricted to only applications user
@@ -249,11 +262,12 b' def build_filter_settings_from_query_dict('
     params = copy.deepcopy(params)
     applications = []
     if not resource_permissions:
-        resource_permissions = ['view']
+        resource_permissions = ["view"]
 
     if request.user:
         applications = UserService.resources_with_perms(
-            request.user, resource_permissions, resource_types=['application'])
+            request.user, resource_permissions, resource_types=["application"]
+        )
 
     # CRITICAL - this ensures our resultset is limited to only the ones
     # user has view permissions
@@ -273,11 +287,11 b' def build_filter_settings_from_query_dict('
     for k, v in list(filter_settings.items()):
         if k in accepted_search_params:
             continue
-        tag_list.append({"name": k, "value": v, "op": 'eq'})
+        tag_list.append({"name": k, "value": v, "op": "eq"})
         # remove the key from filter_settings
         filter_settings.pop(k, None)
     tags = tag_schema.deserialize(tag_list)
-    filter_settings['tags'] = tags
+    filter_settings["tags"] = tags
     return filter_settings
 
 
@@ -299,26 +313,36 b' def permission_tuple_to_dict(data):'
         "resource_type": None,
         "resource_id": None,
         "group_name": None,
-        "group_id": None
+        "group_id": None,
     }
     if data.user:
         out["user_name"] = data.user.user_name
     if data.perm_name == ALL_PERMISSIONS:
-        out['perm_name'] = '__all_permissions__'
+        out["perm_name"] = "__all_permissions__"
     if data.resource:
-        out['resource_name'] = data.resource.resource_name
-        out['resource_type'] = data.resource.resource_type
-        out['resource_id'] = data.resource.resource_id
+        out["resource_name"] = data.resource.resource_name
+        out["resource_type"] = data.resource.resource_type
+        out["resource_id"] = data.resource.resource_id
     if data.group:
-        out['group_name'] = data.group.group_name
-        out['group_id'] = data.group.id
+        out["group_name"] = data.group.group_name
+        out["group_id"] = data.group.id
     return out
 
 
-def get_cached_buckets(request, stats_since, end_time, fn, cache_key,
-                       gap_gen=None, db_session=None, step_interval=None,
+def get_cached_buckets(
+    request,
+    stats_since,
+    end_time,
+    fn,
+    cache_key,
+    gap_gen=None,
+    db_session=None,
+    step_interval=None,
                        iv_extractor=None,
-                       rerange=False, *args, **kwargs):
+    rerange=False,
+    *args,
+    **kwargs
+):
     """ Takes "fn" that should return some data and tries to load the data
     dividing it into daily buckets - if the stats_since and end time give a
     delta bigger than 24hours, then only "todays" data is computed on the fly
@@ -360,25 +384,28 b' def get_cached_buckets(request, stats_since, end_time, fn, cache_key,'
     # do not use custom interval if total time range with new iv would exceed
     # end time
     if not step_interval or stats_since + step_interval >= end_time:
-        if delta < h.time_deltas.get('12h')['delta']:
+        if delta < h.time_deltas.get("12h")["delta"]:
             step_interval = timedelta(seconds=60)
-        elif delta < h.time_deltas.get('3d')['delta']:
+        elif delta < h.time_deltas.get("3d")["delta"]:
             step_interval = timedelta(seconds=60 * 5)
-        elif delta > h.time_deltas.get('2w')['delta']:
+        elif delta > h.time_deltas.get("2w")["delta"]:
             step_interval = timedelta(days=1)
         else:
             step_interval = timedelta(minutes=60)
 
     if step_interval >= timedelta(minutes=60):
-        log.info('cached_buckets:{}: adjusting start time '
-                 'for hourly or daily intervals'.format(cache_key))
+        log.info(
+            "cached_buckets:{}: adjusting start time "
+            "for hourly or daily intervals".format(cache_key)
+        )
         stats_since = stats_since.replace(hour=0, minute=0)
 
-    ranges = [i.start_interval for i in list(gap_gen(stats_since,
-                                                     step_interval, [],
-                                                     end_time=end_time))]
+    ranges = [
+        i.start_interval
+        for i in list(gap_gen(stats_since, step_interval, [], end_time=end_time))
+    ]
     buckets = {}
-    storage_key = 'buckets:' + cache_key + '{}|{}'
+    storage_key = "buckets:" + cache_key + "{}|{}"
     # this means we basicly cache per hour in 3-14 day intervals but i think
     # its fine at this point - will be faster than db access anyways
 
@@ -391,45 +418,67 b' def get_cached_buckets(request, stats_since, end_time, fn, cache_key,'
             k = storage_key.format(step_interval.total_seconds(), r)
             value = request.registry.cache_regions.redis_day_30.get(k)
             # last buckets are never loaded from cache
-            is_last_result = (
-                r >= end_time - timedelta(hours=6) or r in last_ranges)
+            is_last_result = r >= end_time - timedelta(hours=6) or r in last_ranges
             if value is not NO_VALUE and not is_last_result:
-                log.info("cached_buckets:{}: "
-                         "loading range {} from cache".format(cache_key, r))
+                log.info(
+                    "cached_buckets:{}: "
+                    "loading range {} from cache".format(cache_key, r)
+                )
                 buckets[r] = value
             else:
-                log.info("cached_buckets:{}: "
-                         "loading range {} from storage".format(cache_key, r))
+                log.info(
+                    "cached_buckets:{}: "
+                    "loading range {} from storage".format(cache_key, r)
+                )
                 range_size = step_interval
-                if (step_interval == timedelta(minutes=60) and
-                        not is_last_result and rerange):
+                if (
+                    step_interval == timedelta(minutes=60)
+                    and not is_last_result
+                    and rerange
+                ):
                     range_size = timedelta(days=1)
                     r = r.replace(hour=0, minute=0)
-                    log.info("cached_buckets:{}: "
+                    log.info(
+                        "cached_buckets:{}: "
                              "loading collapsed "
-                             "range {} {}".format(cache_key, r,
-                                                  r + range_size))
+                        "range {} {}".format(cache_key, r, r + range_size)
+                    )
                 bucket_data = fn(
-                    request, r, r + range_size, step_interval,
-                    gap_gen, bucket_count=len(ranges), *args, **kwargs)
+                    request,
+                    r,
+                    r + range_size,
+                    step_interval,
+                    gap_gen,
+                    bucket_count=len(ranges),
+                    *args,
+                    **kwargs
+                )
                 for b in bucket_data:
                     b_iv = iv_extractor(b)
                     buckets[b_iv] = b
-                    k2 = storage_key.format(
-                        step_interval.total_seconds(), b_iv)
+                    k2 = storage_key.format(step_interval.total_seconds(), b_iv)
                     request.registry.cache_regions.redis_day_30.set(k2, b)
         log.info("cached_buckets:{}: saving cache".format(cache_key))
     else:
         # bucket count is 1 for short time ranges <= 24h from now
-        bucket_data = fn(request, stats_since, end_time, step_interval,
-                         gap_gen, bucket_count=1, *args, **kwargs)
+        bucket_data = fn(
+            request,
+            stats_since,
+            end_time,
+            step_interval,
+            gap_gen,
+            bucket_count=1,
+            *args,
+            **kwargs
+        )
         for b in bucket_data:
             buckets[iv_extractor(b)] = b
     return buckets
 
 
-def get_cached_split_data(request, stats_since, end_time, fn, cache_key,
-                          db_session=None, *args, **kwargs):
+def get_cached_split_data(
+    request, stats_since, end_time, fn, cache_key, db_session=None, *args, **kwargs
+):
     """ Takes "fn" that should return some data and tries to load the data
     dividing it into 2 buckets - cached "since_from" bucket and "today"
     bucket - then the data can be reduced into single value
@@ -442,43 +491,51 b' def get_cached_split_data(request, stats_since, end_time, fn, cache_key,'
     delta = end_time - stats_since
 
     if delta >= timedelta(minutes=60):
-        log.info('cached_split_data:{}: adjusting start time '
-                 'for hourly or daily intervals'.format(cache_key))
+        log.info(
+            "cached_split_data:{}: adjusting start time "
+            "for hourly or daily intervals".format(cache_key)
+        )
         stats_since = stats_since.replace(hour=0, minute=0)
 
-    storage_key = 'buckets_split_data:' + cache_key + ':{}|{}'
+    storage_key = "buckets_split_data:" + cache_key + ":{}|{}"
     old_end_time = end_time.replace(hour=0, minute=0)
 
-    final_storage_key = storage_key.format(delta.total_seconds(),
-                                           old_end_time)
+    final_storage_key = storage_key.format(delta.total_seconds(), old_end_time)
     older_data = None
 
-    cdata = request.registry.cache_regions.redis_day_7.get(
-        final_storage_key)
+    cdata = request.registry.cache_regions.redis_day_7.get(final_storage_key)
 
     if cdata:
-        log.info("cached_split_data:{}: found old "
-                 "bucket data".format(cache_key))
+        log.info("cached_split_data:{}: found old " "bucket data".format(cache_key))
         older_data = cdata
 
-    if (stats_since < end_time - h.time_deltas.get('24h')['delta'] and
-            not cdata):
-        log.info("cached_split_data:{}: didn't find the "
-                 "start bucket in cache so load older data".format(cache_key))
+    if stats_since < end_time - h.time_deltas.get("24h")["delta"] and not cdata:
+        log.info(
+            "cached_split_data:{}: didn't find the "
+            "start bucket in cache so load older data".format(cache_key)
+        )
         recent_stats_since = old_end_time
-        older_data = fn(request, stats_since, recent_stats_since,
-                        db_session=db_session, *args, **kwargs)
-        request.registry.cache_regions.redis_day_7.set(final_storage_key,
-                                                       older_data)
-    elif stats_since < end_time - h.time_deltas.get('24h')['delta']:
+        older_data = fn(
+            request,
+            stats_since,
+            recent_stats_since,
+            db_session=db_session,
+            *args,
+            **kwargs
+        )
+        request.registry.cache_regions.redis_day_7.set(final_storage_key, older_data)
+    elif stats_since < end_time - h.time_deltas.get("24h")["delta"]:
         recent_stats_since = old_end_time
     else:
         recent_stats_since = stats_since
 
-    log.info("cached_split_data:{}: loading fresh "
-             "data bucksts from last 24h ".format(cache_key))
-    todays_data = fn(request, recent_stats_since, end_time,
-                     db_session=db_session, *args, **kwargs)
+    log.info(
+        "cached_split_data:{}: loading fresh "
+        "data bucksts from last 24h ".format(cache_key)
+    )
+    todays_data = fn(
+        request, recent_stats_since, end_time, db_session=db_session, *args, **kwargs
+    )
     return older_data, todays_data
 
 

backend/src/appenlight/lib/utils/airbrake.py

@@ -24,119 +24,138 b' log = logging.getLogger(__name__)'
 
 def parse_airbrake_xml(request):
     root = request.context.airbrake_xml_etree
-    error = root.find('error')
-    notifier = root.find('notifier')
-    server_env = root.find('server-environment')
-    request_data = root.find('request')
-    user = root.find('current-user')
+    error = root.find("error")
+    notifier = root.find("notifier")
+    server_env = root.find("server-environment")
+    request_data = root.find("request")
+    user = root.find("current-user")
     if request_data is not None:
-        cgi_data = request_data.find('cgi-data')
+        cgi_data = request_data.find("cgi-data")
         if cgi_data is None:
             cgi_data = []
 
     error_dict = {
-        'class_name': error.findtext('class') or '',
-        'error': error.findtext('message') or '',
+        "class_name": error.findtext("class") or "",
+        "error": error.findtext("message") or "",
         "occurences": 1,
         "http_status": 500,
         "priority": 5,
-        "server": 'unknown',
-        'url': 'unknown', 'request': {}
+        "server": "unknown",
+        "url": "unknown",
+        "request": {},
     }
     if user is not None:
-        error_dict['username'] = user.findtext('username') or \
-                                 user.findtext('id')
+        error_dict["username"] = user.findtext("username") or user.findtext("id")
     if notifier is not None:
-        error_dict['client'] = notifier.findtext('name')
+        error_dict["client"] = notifier.findtext("name")
 
     if server_env is not None:
-        error_dict["server"] = server_env.findtext('hostname', 'unknown')
+        error_dict["server"] = server_env.findtext("hostname", "unknown")
 
-    whitelist_environ = ['REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME',
-                         'CONTENT_TYPE', 'HTTP_REFERER']
+    whitelist_environ = [
+        "REMOTE_USER",
+        "REMOTE_ADDR",
+        "SERVER_NAME",
+        "CONTENT_TYPE",
+        "HTTP_REFERER",
+    ]
 
     if request_data is not None:
-        error_dict['url'] = request_data.findtext('url', 'unknown')
-        component = request_data.findtext('component')
-        action = request_data.findtext('action')
+        error_dict["url"] = request_data.findtext("url", "unknown")
+        component = request_data.findtext("component")
+        action = request_data.findtext("action")
         if component and action:
-            error_dict['view_name'] = '%s:%s' % (component, action)
+            error_dict["view_name"] = "%s:%s" % (component, action)
         for node in cgi_data:
-            key = node.get('key')
-            if key.startswith('HTTP') or key in whitelist_environ:
-                error_dict['request'][key] = node.text
-            elif 'query_parameters' in key:
-                error_dict['request']['GET'] = {}
+            key = node.get("key")
+            if key.startswith("HTTP") or key in whitelist_environ:
+                error_dict["request"][key] = node.text
+            elif "query_parameters" in key:
+                error_dict["request"]["GET"] = {}
                 for x in node:
-                    error_dict['request']['GET'][x.get('key')] = x.text
-            elif 'request_parameters' in key:
-                error_dict['request']['POST'] = {}
+                    error_dict["request"]["GET"][x.get("key")] = x.text
+            elif "request_parameters" in key:
+                error_dict["request"]["POST"] = {}
                 for x in node:
-                    error_dict['request']['POST'][x.get('key')] = x.text
-            elif key.endswith('cookie'):
-                error_dict['request']['COOKIE'] = {}
+                    error_dict["request"]["POST"][x.get("key")] = x.text
+            elif key.endswith("cookie"):
+                error_dict["request"]["COOKIE"] = {}
                 for x in node:
-                    error_dict['request']['COOKIE'][x.get('key')] = x.text
-            elif key.endswith('request_id'):
-                error_dict['request_id'] = node.text
-            elif key.endswith('session'):
-                error_dict['request']['SESSION'] = {}
+                    error_dict["request"]["COOKIE"][x.get("key")] = x.text
+            elif key.endswith("request_id"):
+                error_dict["request_id"] = node.text
+            elif key.endswith("session"):
+                error_dict["request"]["SESSION"] = {}
                 for x in node:
-                    error_dict['request']['SESSION'][x.get('key')] = x.text
+                    error_dict["request"]["SESSION"][x.get("key")] = x.text
             else:
-                if key in ['rack.session.options']:
+                if key in ["rack.session.options"]:
                     # skip secret configs
                     continue
                 try:
                     if len(node):
-                        error_dict['request'][key] = dict(
-                            [(x.get('key'), x.text,) for x in node])
+                        error_dict["request"][key] = dict(
+                            [(x.get("key"), x.text) for x in node]
+                        )
                     else:
-                        error_dict['request'][key] = node.text
+                        error_dict["request"][key] = node.text
                 except Exception as e:
-                    log.warning('Airbrake integration exception: %s' % e)
+                    log.warning("Airbrake integration exception: %s" % e)
 
-            error_dict['request'].pop('HTTP_COOKIE', '')
+            error_dict["request"].pop("HTTP_COOKIE", "")
 
-        error_dict['ip'] = error_dict.pop('REMOTE_ADDR', '')
-        error_dict['user_agent'] = error_dict.pop('HTTP_USER_AGENT', '')
-    if 'request_id' not in error_dict:
-        error_dict['request_id'] = str(uuid.uuid4())
+        error_dict["ip"] = error_dict.pop("REMOTE_ADDR", "")
+        error_dict["user_agent"] = error_dict.pop("HTTP_USER_AGENT", "")
+    if "request_id" not in error_dict:
+        error_dict["request_id"] = str(uuid.uuid4())
     if request.context.possibly_public:
         # set ip for reports that come from airbrake js client
         error_dict["timestamp"] = datetime.utcnow()
         if request.environ.get("HTTP_X_FORWARDED_FOR"):
-            ip = request.environ.get("HTTP_X_FORWARDED_FOR", '')
-            first_ip = ip.split(',')[0]
+            ip = request.environ.get("HTTP_X_FORWARDED_FOR", "")
+            first_ip = ip.split(",")[0]
             remote_addr = first_ip.strip()
         else:
-            remote_addr = (request.environ.get("HTTP_X_REAL_IP") or
-                           request.environ.get('REMOTE_ADDR'))
+            remote_addr = request.environ.get("HTTP_X_REAL_IP") or request.environ.get(
+                "REMOTE_ADDR"
+            )
         error_dict["ip"] = remote_addr
 
-    blacklist = ['password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf',
-                 'session', 'test']
+    blacklist = [
+        "password",
+        "passwd",
+        "pwd",
+        "auth_tkt",
+        "secret",
+        "csrf",
+        "session",
+        "test",
+    ]
 
     lines = []
-    for l in error.find('backtrace'):
-        lines.append({'file': l.get("file", ""),
-                      'line': l.get("number", ""),
-                      'fn': l.get("method", ""),
-                      'module': l.get("module", ""),
-                      'cline': l.get("method", ""),
-                      'vars': {}})
-    error_dict['traceback'] = list(reversed(lines))
+    for l in error.find("backtrace"):
+        lines.append(
+            {
+                "file": l.get("file", ""),
+                "line": l.get("number", ""),
+                "fn": l.get("method", ""),
+                "module": l.get("module", ""),
+                "cline": l.get("method", ""),
+                "vars": {},
+            }
+        )
+    error_dict["traceback"] = list(reversed(lines))
     # filtering is not provided by airbrake
     keys_to_check = (
-        error_dict['request'].get('COOKIE'),
-        error_dict['request'].get('COOKIES'),
-        error_dict['request'].get('POST'),
-        error_dict['request'].get('SESSION'),
+        error_dict["request"].get("COOKIE"),
+        error_dict["request"].get("COOKIES"),
+        error_dict["request"].get("POST"),
+        error_dict["request"].get("SESSION"),
     )
     for source in [_f for _f in keys_to_check if _f]:
         for k in source.keys():
             for bad_key in blacklist:
                 if bad_key in k.lower():
-                    source[k] = '***'
+                    source[k] = "***"
 
     return error_dict

backend/src/appenlight/lib/utils/date_utils.py

@@ -22,12 +22,12 b' log = logging.getLogger(__name__)'
 
 
 def to_relativedelta(time_delta):
-    return relativedelta(seconds=int(time_delta.total_seconds()),
-                         microseconds=time_delta.microseconds)
+    return relativedelta(
+        seconds=int(time_delta.total_seconds()), microseconds=time_delta.microseconds
+    )
 
 
-def convert_date(date_str, return_utcnow_if_wrong=True,
-                 normalize_future=False):
+def convert_date(date_str, return_utcnow_if_wrong=True, normalize_future=False):
     utcnow = datetime.utcnow()
     if isinstance(date_str, datetime):
         # get rid of tzinfo
@@ -36,21 +36,21 b' def convert_date(date_str, return_utcnow_if_wrong=True,'
         return utcnow
     try:
         try:
-            if 'Z' in date_str:
-                date_str = date_str[:date_str.index('Z')]
-            if '.' in date_str:
-                date = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f')
+            if "Z" in date_str:
+                date_str = date_str[: date_str.index("Z")]
+            if "." in date_str:
+                date = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%S.%f")
             else:
-                date = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S')
+                date = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%S")
         except Exception:
             # bw compat with old client
-            date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S,%f')
+            date = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S,%f")
     except Exception:
         if return_utcnow_if_wrong:
             date = utcnow
         else:
             date = None
     if normalize_future and date and date > (utcnow + timedelta(minutes=3)):
-        log.warning('time %s in future + 3 min, normalizing' % date)
+        log.warning("time %s in future + 3 min, normalizing" % date)
         return utcnow
     return date

backend/src/appenlight/lib/utils/sentry.py

@@ -19,45 +19,68 b' from datetime import timedelta'
 from appenlight.lib.enums import LogLevelPython, ParsedSentryEventType
 
 EXCLUDED_LOG_VARS = [
-    'args', 'asctime', 'created', 'exc_info', 'exc_text', 'filename',
-    'funcName', 'levelname', 'levelno', 'lineno', 'message', 'module', 'msecs',
-    'msg', 'name', 'pathname', 'process', 'processName', 'relativeCreated',
-    'thread', 'threadName']
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "message",
+    "module",
+    "msecs",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "thread",
+    "threadName",
+]
 
 EXCLUDE_SENTRY_KEYS = [
-    'csp',
-    'culprit',
-    'event_id',
-    'exception',
-    'extra',
-    'level',
-    'logentry',
-    'logger',
-    'message',
-    'modules',
-    'platform',
-    'query',
-    'release',
-    'request',
-    'sentry.interfaces.Csp', 'sentry.interfaces.Exception',
-    'sentry.interfaces.Http', 'sentry.interfaces.Message',
-    'sentry.interfaces.Query',
-    'sentry.interfaces.Stacktrace',
-    'sentry.interfaces.Template', 'sentry.interfaces.User',
-    'sentry.interfaces.csp.Csp',
-    'sentry.interfaces.exception.Exception',
-    'sentry.interfaces.http.Http',
-    'sentry.interfaces.message.Message',
-    'sentry.interfaces.query.Query',
-    'sentry.interfaces.stacktrace.Stacktrace',
-    'sentry.interfaces.template.Template',
-    'sentry.interfaces.user.User', 'server_name',
-    'stacktrace',
-    'tags',
-    'template',
-    'time_spent',
-    'timestamp',
-    'user']
+    "csp",
+    "culprit",
+    "event_id",
+    "exception",
+    "extra",
+    "level",
+    "logentry",
+    "logger",
+    "message",
+    "modules",
+    "platform",
+    "query",
+    "release",
+    "request",
+    "sentry.interfaces.Csp",
+    "sentry.interfaces.Exception",
+    "sentry.interfaces.Http",
+    "sentry.interfaces.Message",
+    "sentry.interfaces.Query",
+    "sentry.interfaces.Stacktrace",
+    "sentry.interfaces.Template",
+    "sentry.interfaces.User",
+    "sentry.interfaces.csp.Csp",
+    "sentry.interfaces.exception.Exception",
+    "sentry.interfaces.http.Http",
+    "sentry.interfaces.message.Message",
+    "sentry.interfaces.query.Query",
+    "sentry.interfaces.stacktrace.Stacktrace",
+    "sentry.interfaces.template.Template",
+    "sentry.interfaces.user.User",
+    "server_name",
+    "stacktrace",
+    "tags",
+    "template",
+    "time_spent",
+    "timestamp",
+    "user",
+]
 
 
 def get_keys(list_of_keys, json_body):
@@ -67,9 +90,10 b' def get_keys(list_of_keys, json_body):'
 
 
 def get_logentry(json_body):
-    key_names = ['logentry',
-                 'sentry.interfaces.message.Message',
-                 'sentry.interfaces.Message'
+    key_names = [
+        "logentry",
+        "sentry.interfaces.message.Message",
+        "sentry.interfaces.Message",
                  ]
     logentry = get_keys(key_names, json_body)
     return logentry
@@ -77,20 +101,21 b' def get_logentry(json_body):'
 
 def get_exception(json_body):
     parsed_exception = {}
-    key_names = ['exception',
-                 'sentry.interfaces.exception.Exception',
-                 'sentry.interfaces.Exception'
+    key_names = [
+        "exception",
+        "sentry.interfaces.exception.Exception",
+        "sentry.interfaces.Exception",
                  ]
     exception = get_keys(key_names, json_body) or {}
     if exception:
         if isinstance(exception, dict):
-            exception = exception['values'][0]
+            exception = exception["values"][0]
         else:
             exception = exception[0]
 
-    parsed_exception['type'] = exception.get('type')
-    parsed_exception['value'] = exception.get('value')
-    parsed_exception['module'] = exception.get('module')
+    parsed_exception["type"] = exception.get("type")
+    parsed_exception["value"] = exception.get("value")
+    parsed_exception["module"] = exception.get("module")
     parsed_stacktrace = get_stacktrace(exception) or {}
     parsed_exception = exception or {}
     return parsed_exception, parsed_stacktrace
@@ -98,20 +123,22 b' def get_exception(json_body):'
 
 def get_stacktrace(json_body):
     parsed_stacktrace = []
-    key_names = ['stacktrace',
-                 'sentry.interfaces.stacktrace.Stacktrace',
-                 'sentry.interfaces.Stacktrace'
+    key_names = [
+        "stacktrace",
+        "sentry.interfaces.stacktrace.Stacktrace",
+        "sentry.interfaces.Stacktrace",
                  ]
     stacktrace = get_keys(key_names, json_body)
     if stacktrace:
-        for frame in stacktrace['frames']:
+        for frame in stacktrace["frames"]:
             parsed_stacktrace.append(
-                {"cline": frame.get('context_line', ''),
-                 "file": frame.get('filename', ''),
-                 "module": frame.get('module', ''),
-                 "fn": frame.get('function', ''),
-                 "line": frame.get('lineno', ''),
-                 "vars": list(frame.get('vars', {}).items())
+                {
+                    "cline": frame.get("context_line", ""),
+                    "file": frame.get("filename", ""),
+                    "module": frame.get("module", ""),
+                    "fn": frame.get("function", ""),
+                    "line": frame.get("lineno", ""),
+                    "vars": list(frame.get("vars", {}).items()),
                  }
             )
     return parsed_stacktrace
@@ -119,19 +146,21 b' def get_stacktrace(json_body):'
 
 def get_template(json_body):
     parsed_template = {}
-    key_names = ['template',
-                 'sentry.interfaces.template.Template',
-                 'sentry.interfaces.Template'
+    key_names = [
+        "template",
+        "sentry.interfaces.template.Template",
+        "sentry.interfaces.Template",
                  ]
     template = get_keys(key_names, json_body)
     if template:
-        for frame in template['frames']:
+        for frame in template["frames"]:
             parsed_template.append(
-                {"cline": frame.get('context_line', ''),
-                 "file": frame.get('filename', ''),
-                 "fn": '',
-                 "line": frame.get('lineno', ''),
-                 "vars": []
+                {
+                    "cline": frame.get("context_line", ""),
+                    "file": frame.get("filename", ""),
+                    "fn": "",
+                    "line": frame.get("lineno", ""),
+                    "vars": [],
                  }
             )
 
@@ -140,16 +169,13 b' def get_template(json_body):'
 
 def get_request(json_body):
     parsed_http = {}
-    key_names = ['request',
-                 'sentry.interfaces.http.Http',
-                 'sentry.interfaces.Http'
-                 ]
+    key_names = ["request", "sentry.interfaces.http.Http", "sentry.interfaces.Http"]
     http = get_keys(key_names, json_body) or {}
     for k, v in http.items():
-        if k == 'headers':
-            parsed_http['headers'] = {}
-            for sk, sv in http['headers'].items():
-                parsed_http['headers'][sk.title()] = sv
+        if k == "headers":
+            parsed_http["headers"] = {}
+            for sk, sv in http["headers"].items():
+                parsed_http["headers"][sk.title()] = sv
         else:
             parsed_http[k.lower()] = v
     return parsed_http
@@ -157,53 +183,47 b' def get_request(json_body):'
 
 def get_user(json_body):
     parsed_user = {}
-    key_names = ['user',
-                 'sentry.interfaces.user.User',
-                 'sentry.interfaces.User'
-                 ]
+    key_names = ["user", "sentry.interfaces.user.User", "sentry.interfaces.User"]
     user = get_keys(key_names, json_body)
     if user:
-        parsed_user['id'] = user.get('id')
-        parsed_user['username'] = user.get('username')
-        parsed_user['email'] = user.get('email')
-        parsed_user['ip_address'] = user.get('ip_address')
+        parsed_user["id"] = user.get("id")
+        parsed_user["username"] = user.get("username")
+        parsed_user["email"] = user.get("email")
+        parsed_user["ip_address"] = user.get("ip_address")
 
     return parsed_user
 
 
 def get_query(json_body):
     query = None
-    key_name = ['query',
-                'sentry.interfaces.query.Query',
-                'sentry.interfaces.Query'
-                ]
+    key_name = ["query", "sentry.interfaces.query.Query", "sentry.interfaces.Query"]
     query = get_keys(key_name, json_body)
     return query
 
 
 def parse_sentry_event(json_body):
-    request_id = json_body.get('event_id')
+    request_id = json_body.get("event_id")
 
     # required
-    message = json_body.get('message')
-    log_timestamp = json_body.get('timestamp')
-    level = json_body.get('level')
+    message = json_body.get("message")
+    log_timestamp = json_body.get("timestamp")
+    level = json_body.get("level")
     if isinstance(level, int):
         level = LogLevelPython.key_from_value(level)
 
-    namespace = json_body.get('logger')
-    language = json_body.get('platform')
+    namespace = json_body.get("logger")
+    language = json_body.get("platform")
 
     # optional
-    server_name = json_body.get('server_name')
-    culprit = json_body.get('culprit')
-    release = json_body.get('release')
+    server_name = json_body.get("server_name")
+    culprit = json_body.get("culprit")
+    release = json_body.get("release")
 
-    tags = json_body.get('tags', {})
-    if hasattr(tags, 'items'):
+    tags = json_body.get("tags", {})
+    if hasattr(tags, "items"):
         tags = list(tags.items())
-    extra = json_body.get('extra', {})
-    if hasattr(extra, 'items'):
+    extra = json_body.get("extra", {})
+    if hasattr(extra, "items"):
         extra = list(extra.items())
 
     parsed_req = get_request(json_body)
@@ -212,12 +232,13 b' def parse_sentry_event(json_body):'
     query = get_query(json_body)
 
     # other unidentified keys found
-    other_keys = [(k, json_body[k]) for k in json_body.keys()
-                  if k not in EXCLUDE_SENTRY_KEYS]
+    other_keys = [
+        (k, json_body[k]) for k in json_body.keys() if k not in EXCLUDE_SENTRY_KEYS
+    ]
 
     logentry = get_logentry(json_body)
     if logentry:
-        message = logentry['message']
+        message = logentry["message"]
 
     exception, stacktrace = get_exception(json_body)
 
@@ -227,70 +248,70 b' def parse_sentry_event(json_body):'
         event_type = ParsedSentryEventType.LOG
 
         event_dict = {
-            'log_level': level,
-            'message': message,
-            'namespace': namespace,
-            'request_id': request_id,
-            'server': server_name,
-            'date': log_timestamp,
-            'tags': tags
+            "log_level": level,
+            "message": message,
+            "namespace": namespace,
+            "request_id": request_id,
+            "server": server_name,
+            "date": log_timestamp,
+            "tags": tags,
         }
-        event_dict['tags'].extend(
-            [(k, v) for k, v in extra if k not in EXCLUDED_LOG_VARS])
+        event_dict["tags"].extend(
+            [(k, v) for k, v in extra if k not in EXCLUDED_LOG_VARS]
+        )
 
         # other keys can be various object types
-        event_dict['tags'].extend([(k, v) for k, v in other_keys
-                                   if isinstance(v, str)])
+        event_dict["tags"].extend([(k, v) for k, v in other_keys if isinstance(v, str)])
         if culprit:
-            event_dict['tags'].append(('sentry_culprit', culprit))
+            event_dict["tags"].append(("sentry_culprit", culprit))
         if language:
-            event_dict['tags'].append(('sentry_language', language))
+            event_dict["tags"].append(("sentry_language", language))
         if release:
-            event_dict['tags'].append(('sentry_release', release))
+            event_dict["tags"].append(("sentry_release", release))
 
     if exception or stacktrace or alt_stacktrace or template:
         event_type = ParsedSentryEventType.ERROR_REPORT
         event_dict = {
-            'client': 'sentry',
-            'error': message,
-            'namespace': namespace,
-            'request_id': request_id,
-            'server': server_name,
-            'start_time': log_timestamp,
-            'end_time': None,
-            'tags': tags,
-            'extra': extra,
-            'language': language,
-            'view_name': json_body.get('culprit'),
-            'http_status': None,
-            'username': None,
-            'url': parsed_req.get('url'),
-            'ip': None,
-            'user_agent': None,
-            'request': None,
-            'slow_calls': None,
-            'request_stats': None,
-            'traceback': None
+            "client": "sentry",
+            "error": message,
+            "namespace": namespace,
+            "request_id": request_id,
+            "server": server_name,
+            "start_time": log_timestamp,
+            "end_time": None,
+            "tags": tags,
+            "extra": extra,
+            "language": language,
+            "view_name": json_body.get("culprit"),
+            "http_status": None,
+            "username": None,
+            "url": parsed_req.get("url"),
+            "ip": None,
+            "user_agent": None,
+            "request": None,
+            "slow_calls": None,
+            "request_stats": None,
+            "traceback": None,
         }
 
-        event_dict['extra'].extend(other_keys)
+        event_dict["extra"].extend(other_keys)
         if release:
-            event_dict['tags'].append(('sentry_release', release))
-        event_dict['request'] = parsed_req
-        if 'headers' in parsed_req:
-            event_dict['user_agent'] = parsed_req['headers'].get('User-Agent')
-        if 'env' in parsed_req:
-            event_dict['ip'] = parsed_req['env'].get('REMOTE_ADDR')
-        ts_ms = int(json_body.get('time_spent') or 0)
+            event_dict["tags"].append(("sentry_release", release))
+        event_dict["request"] = parsed_req
+        if "headers" in parsed_req:
+            event_dict["user_agent"] = parsed_req["headers"].get("User-Agent")
+        if "env" in parsed_req:
+            event_dict["ip"] = parsed_req["env"].get("REMOTE_ADDR")
+        ts_ms = int(json_body.get("time_spent") or 0)
         if ts_ms > 0:
-            event_dict['end_time'] = event_dict['start_time'] + \
-                                     timedelta(milliseconds=ts_ms)
+            event_dict["end_time"] = event_dict["start_time"] + timedelta(
+                milliseconds=ts_ms
+            )
         if stacktrace or alt_stacktrace or template:
-            event_dict['traceback'] = stacktrace or alt_stacktrace or template
+            event_dict["traceback"] = stacktrace or alt_stacktrace or template
         for k in list(event_dict.keys()):
             if event_dict[k] is None:
                 del event_dict[k]
         if user:
-            event_dict['username'] = user['username'] or user['id'] \
-                                     or user['email']
+            event_dict["username"] = user["username"] or user["id"] or user["email"]
     return event_dict, event_type

backend/src/appenlight/migrations/__init__.py

@@ -13,5 +13,3 b''
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-

backend/src/appenlight/migrations/env.py

@@ -41,7 +41,7 b' target_metadata = MetaData(naming_convention=NAMING_CONVENTION)'
 # my_important_option = config.get_main_option("my_important_option")
 # ... etc.
 
-VERSION_TABLE_NAME = 'alembic_appenlight_version'
+VERSION_TABLE_NAME = "alembic_appenlight_version"
 
 
 def run_migrations_offline():
@@ -57,9 +57,12 b' def run_migrations_offline():'
 
     """
     url = config.get_main_option("sqlalchemy.url")
-    context.configure(url=url, target_metadata=target_metadata,
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
                       transaction_per_migration=True,
-                      version_table=VERSION_TABLE_NAME)
+        version_table=VERSION_TABLE_NAME,
+    )
 
     with context.begin_transaction():
         context.run_migrations()
@@ -74,15 +77,16 b' def run_migrations_online():'
     """
     engine = engine_from_config(
         config.get_section(config.config_ini_section),
-        prefix='sqlalchemy.',
-        poolclass=pool.NullPool)
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
 
     connection = engine.connect()
     context.configure(
         connection=connection,
         target_metadata=target_metadata,
         transaction_per_migration=True,
-        version_table=VERSION_TABLE_NAME
+        version_table=VERSION_TABLE_NAME,
     )
 
     try:

backend/src/appenlight/migrations/versions/55b6e612672f_initial_tables.py

@@ -23,7 +23,7 b' Create Date: 2014-10-13 23:47:38.295159'
 """
 
 # revision identifiers, used by Alembic.
-revision = '55b6e612672f'
+revision = "55b6e612672f"
 down_revision = None
 
 from alembic import op
@@ -31,348 +31,514 b' import sqlalchemy as sa'
 
 
 def upgrade():
-    op.add_column('users', sa.Column('first_name', sa.Unicode(25)))
-    op.add_column('users', sa.Column('last_name', sa.Unicode(50)))
-    op.add_column('users', sa.Column('company_name', sa.Unicode(255)))
-    op.add_column('users', sa.Column('company_address', sa.Unicode(255)))
-    op.add_column('users', sa.Column('phone1', sa.Unicode(25)))
-    op.add_column('users', sa.Column('phone2', sa.Unicode(25)))
-    op.add_column('users', sa.Column('zip_code', sa.Unicode(25)))
-    op.add_column('users', sa.Column('default_report_sort', sa.Unicode(20), nullable=False, server_default="newest"))
-    op.add_column('users', sa.Column('city', sa.Unicode(128)))
-    op.add_column('users', sa.Column('notes', sa.UnicodeText, server_default=''))
-    op.add_column('users', sa.Column('notifications', sa.Boolean(), nullable=False, server_default='true'))
-    op.add_column('users', sa.Column('registration_ip', sa.Unicode(40), nullable=False, server_default=''))
+    op.add_column("users", sa.Column("first_name", sa.Unicode(25)))
+    op.add_column("users", sa.Column("last_name", sa.Unicode(50)))
+    op.add_column("users", sa.Column("company_name", sa.Unicode(255)))
+    op.add_column("users", sa.Column("company_address", sa.Unicode(255)))
+    op.add_column("users", sa.Column("phone1", sa.Unicode(25)))
+    op.add_column("users", sa.Column("phone2", sa.Unicode(25)))
+    op.add_column("users", sa.Column("zip_code", sa.Unicode(25)))
+    op.add_column(
+        "users",
+        sa.Column(
+            "default_report_sort",
+            sa.Unicode(20),
+            nullable=False,
+            server_default="newest",
+        ),
+    )
+    op.add_column("users", sa.Column("city", sa.Unicode(128)))
+    op.add_column("users", sa.Column("notes", sa.UnicodeText, server_default=""))
+    op.add_column(
+        "users",
+        sa.Column("notifications", sa.Boolean(), nullable=False, server_default="true"),
+    )
+    op.add_column(
+        "users",
+        sa.Column("registration_ip", sa.Unicode(40), nullable=False, server_default=""),
+    )
 
     op.create_table(
-        'integrations',
-        sa.Column('id', sa.Integer(), primary_key=True),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('integration_name', sa.Unicode(64)),
-        sa.Column('config', sa.dialects.postgresql.JSON, nullable=False),
-        sa.Column('modified_date', sa.DateTime(), nullable=False, server_default=sa.func.now()),
-        sa.Column('external_id', sa.Unicode(255)),
-        sa.Column('external_id2', sa.Unicode(255))
+        "integrations",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column("integration_name", sa.Unicode(64)),
+        sa.Column("config", sa.dialects.postgresql.JSON, nullable=False),
+        sa.Column(
+            "modified_date", sa.DateTime(), nullable=False, server_default=sa.func.now()
+        ),
+        sa.Column("external_id", sa.Unicode(255)),
+        sa.Column("external_id2", sa.Unicode(255)),
     )
 
     op.create_table(
-        'alert_channels',
-        sa.Column('owner_id', sa.Integer(),
-                  sa.ForeignKey('users.id', onupdate='cascade',
-                                ondelete='cascade'), nullable=False),
-        sa.Column('channel_name', sa.Unicode(25), nullable=False),
-        sa.Column('channel_value', sa.Unicode(80), nullable=False),
-        sa.Column('channel_json_conf', sa.dialects.postgresql.JSON, nullable=False),
-        sa.Column('channel_validated', sa.Boolean, nullable=False, server_default='False'),
-        sa.Column('send_alerts', sa.Boolean, nullable=False, server_default='True'),
-        sa.Column('notify_only_first', sa.Boolean, nullable=False, server_default='False'),
-        sa.Column('daily_digest', sa.Boolean, nullable=False, server_default='True'),
-        sa.Column('pkey', sa.Integer(), primary_key=True),
-        sa.Column('integration_id', sa.Integer,
-                  sa.ForeignKey('integrations.id', onupdate='cascade',
-                                ondelete='cascade')),
-    )
-    op.create_unique_constraint('uq_alert_channels', 'alert_channels',
-                                ["owner_id", "channel_name", "channel_value"])
+        "alert_channels",
+        sa.Column(
+            "owner_id",
+            sa.Integer(),
+            sa.ForeignKey("users.id", onupdate="cascade", ondelete="cascade"),
+            nullable=False,
+        ),
+        sa.Column("channel_name", sa.Unicode(25), nullable=False),
+        sa.Column("channel_value", sa.Unicode(80), nullable=False),
+        sa.Column("channel_json_conf", sa.dialects.postgresql.JSON, nullable=False),
+        sa.Column(
+            "channel_validated", sa.Boolean, nullable=False, server_default="False"
+        ),
+        sa.Column("send_alerts", sa.Boolean, nullable=False, server_default="True"),
+        sa.Column(
+            "notify_only_first", sa.Boolean, nullable=False, server_default="False"
+        ),
+        sa.Column("daily_digest", sa.Boolean, nullable=False, server_default="True"),
+        sa.Column("pkey", sa.Integer(), primary_key=True),
+        sa.Column(
+            "integration_id",
+            sa.Integer,
+            sa.ForeignKey("integrations.id", onupdate="cascade", ondelete="cascade"),
+        ),
+    )
+    op.create_unique_constraint(
+        "uq_alert_channels",
+        "alert_channels",
+        ["owner_id", "channel_name", "channel_value"],
+    )
 
     op.create_table(
-        'alert_channels_actions',
-        sa.Column('owner_id', sa.Integer(), nullable=False),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('pkey', sa.Integer(), primary_key=True),
-        sa.Column('action', sa.Unicode(10), nullable=False, server_default='always'),
-        sa.Column('rule', sa.dialects.postgresql.JSON),
-        sa.Column('type', sa.Unicode(10), index=True),
-        sa.Column('other_id', sa.Unicode(40), index=True),
-        sa.Column('config', sa.dialects.postgresql.JSON),
-        sa.Column('name', sa.Unicode(255), server_default='')
+        "alert_channels_actions",
+        sa.Column("owner_id", sa.Integer(), nullable=False),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column("pkey", sa.Integer(), primary_key=True),
+        sa.Column("action", sa.Unicode(10), nullable=False, server_default="always"),
+        sa.Column("rule", sa.dialects.postgresql.JSON),
+        sa.Column("type", sa.Unicode(10), index=True),
+        sa.Column("other_id", sa.Unicode(40), index=True),
+        sa.Column("config", sa.dialects.postgresql.JSON),
+        sa.Column("name", sa.Unicode(255), server_default=""),
     )
 
-
     op.create_table(
-        'application_postprocess_conf',
-        sa.Column('pkey', sa.Integer(), primary_key=True),
-        sa.Column('do', sa.Unicode(25), nullable=False),
-        sa.Column('new_value', sa.UnicodeText(), nullable=False, server_default=''),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id',
-                                onupdate='cascade',
-                                ondelete='cascade'), nullable=False),
-        sa.Column('rule', sa.dialects.postgresql.JSON),
+        "application_postprocess_conf",
+        sa.Column("pkey", sa.Integer(), primary_key=True),
+        sa.Column("do", sa.Unicode(25), nullable=False),
+        sa.Column("new_value", sa.UnicodeText(), nullable=False, server_default=""),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+            nullable=False,
+        ),
+        sa.Column("rule", sa.dialects.postgresql.JSON),
     )
 
     op.create_table(
-        'applications',
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade'), nullable=False,
-                  primary_key=True, autoincrement=False),
-        sa.Column('domains', sa.UnicodeText, nullable=False),
-        sa.Column('api_key', sa.Unicode(32), nullable=False, index=True),
-        sa.Column('default_grouping', sa.Unicode(20), nullable=False, server_default='url_type'),
-        sa.Column('public_key', sa.Unicode(32), nullable=False, index=True),
-        sa.Column('error_report_threshold', sa.Integer(), server_default='10', nullable=False),
-        sa.Column('slow_report_threshold', sa.Integer(), server_default='10', nullable=False),
-        sa.Column('apdex_threshold', sa.Float(), server_default='0.7', nullable=False),
-        sa.Column('allow_permanent_storage', sa.Boolean(), server_default="false", nullable=False),
-    )
-    op.create_unique_constraint(None, 'applications',
-                                ["public_key"])
-    op.create_unique_constraint(None, 'applications',
-                                ["api_key"])
+        "applications",
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+            nullable=False,
+            primary_key=True,
+            autoincrement=False,
+        ),
+        sa.Column("domains", sa.UnicodeText, nullable=False),
+        sa.Column("api_key", sa.Unicode(32), nullable=False, index=True),
+        sa.Column(
+            "default_grouping",
+            sa.Unicode(20),
+            nullable=False,
+            server_default="url_type",
+        ),
+        sa.Column("public_key", sa.Unicode(32), nullable=False, index=True),
+        sa.Column(
+            "error_report_threshold", sa.Integer(), server_default="10", nullable=False
+        ),
+        sa.Column(
+            "slow_report_threshold", sa.Integer(), server_default="10", nullable=False
+        ),
+        sa.Column("apdex_threshold", sa.Float(), server_default="0.7", nullable=False),
+        sa.Column(
+            "allow_permanent_storage",
+            sa.Boolean(),
+            server_default="false",
+            nullable=False,
+        ),
+    )
+    op.create_unique_constraint(None, "applications", ["public_key"])
+    op.create_unique_constraint(None, "applications", ["api_key"])
 
     op.create_table(
-        'metrics',
-        sa.Column('pkey', sa.types.BigInteger, nullable=False, primary_key=True),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id',
-                                onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('timestamp', sa.DateTime),
-        sa.Column('namespace', sa.Unicode(255)),
-        sa.Column('tags', sa.dialects.postgresql.JSON, server_default="{}")
+        "metrics",
+        sa.Column("pkey", sa.types.BigInteger, nullable=False, primary_key=True),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column("timestamp", sa.DateTime),
+        sa.Column("namespace", sa.Unicode(255)),
+        sa.Column("tags", sa.dialects.postgresql.JSON, server_default="{}"),
     )
 
     op.create_table(
-        'events',
-        sa.Column('id', sa.Integer, nullable=False, primary_key=True),
-        sa.Column('start_date', sa.DateTime, nullable=False, index=True),
-        sa.Column('end_date', sa.DateTime),
-        sa.Column('status', sa.Integer(), nullable=False, index=True),
-        sa.Column('event_type', sa.Integer(), nullable=False, index=True),
-        sa.Column('origin_user_id', sa.Integer()),
-        sa.Column('target_user_id', sa.Integer()),
-        sa.Column('resource_id', sa.Integer(), index=True),
-        sa.Column('text', sa.UnicodeText, server_default=''),
-        sa.Column('values', sa.dialects.postgresql.JSON),
-        sa.Column('target_id', sa.Integer()),
-        sa.Column('target_uuid', sa.Unicode(40), index=True)
+        "events",
+        sa.Column("id", sa.Integer, nullable=False, primary_key=True),
+        sa.Column("start_date", sa.DateTime, nullable=False, index=True),
+        sa.Column("end_date", sa.DateTime),
+        sa.Column("status", sa.Integer(), nullable=False, index=True),
+        sa.Column("event_type", sa.Integer(), nullable=False, index=True),
+        sa.Column("origin_user_id", sa.Integer()),
+        sa.Column("target_user_id", sa.Integer()),
+        sa.Column("resource_id", sa.Integer(), index=True),
+        sa.Column("text", sa.UnicodeText, server_default=""),
+        sa.Column("values", sa.dialects.postgresql.JSON),
+        sa.Column("target_id", sa.Integer()),
+        sa.Column("target_uuid", sa.Unicode(40), index=True),
     )
 
     op.create_table(
-        'logs',
-        sa.Column('log_id', sa.types.BigInteger, nullable=False, primary_key=True),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id',
-                                onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('log_level', sa.SmallInteger(), nullable=False),
-        sa.Column('primary_key', sa.Unicode(128), nullable=True),
-        sa.Column('message', sa.UnicodeText, nullable=False, server_default=''),
-        sa.Column('timestamp', sa.DateTime),
-        sa.Column('namespace', sa.Unicode(255)),
-        sa.Column('request_id', sa.Unicode(40)),
-        sa.Column('tags', sa.dialects.postgresql.JSON, server_default="{}"),
-        sa.Column('permanent', sa.Boolean(), server_default="false",
-                  nullable=False)
+        "logs",
+        sa.Column("log_id", sa.types.BigInteger, nullable=False, primary_key=True),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column("log_level", sa.SmallInteger(), nullable=False),
+        sa.Column("primary_key", sa.Unicode(128), nullable=True),
+        sa.Column("message", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column("timestamp", sa.DateTime),
+        sa.Column("namespace", sa.Unicode(255)),
+        sa.Column("request_id", sa.Unicode(40)),
+        sa.Column("tags", sa.dialects.postgresql.JSON, server_default="{}"),
+        sa.Column("permanent", sa.Boolean(), server_default="false", nullable=False),
     )
 
     op.create_table(
-        'reports_groups',
-        sa.Column('id', sa.types.BigInteger, primary_key=True),
-        sa.Column('resource_id', sa.Integer,
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade'), nullable=False),
-        sa.Column('priority', sa.Integer, nullable=False, server_default="5"),
-        sa.Column('first_timestamp', sa.DateTime(), nullable=False, server_default=sa.func.now()),
-        sa.Column('last_timestamp', sa.DateTime()),
-        sa.Column('error', sa.UnicodeText, nullable=False, server_default=""),
-        sa.Column('grouping_hash', sa.Unicode(40), nullable=False, server_default=""),
-        sa.Column('triggered_postprocesses_ids', sa.dialects.postgresql.JSON, nullable=False, server_default="[]"),
-        sa.Column('report_type', sa.Integer, nullable=False, server_default="0"),
-        sa.Column('total_reports', sa.Integer, nullable=False, server_default="0"),
-        sa.Column('last_report', sa.Integer, nullable=False, server_default="0"),
-        sa.Column('occurences', sa.Integer, nullable=False, server_default="1"),
-        sa.Column('average_duration', sa.Float(), nullable=False, server_default="0"),
-        sa.Column('summed_duration', sa.Float(), nullable=False, server_default="0"),
-        sa.Column('notified', sa.Boolean, nullable=False, server_default="False"),
-        sa.Column('fixed', sa.Boolean, nullable=False, server_default="False"),
-        sa.Column('public', sa.Boolean, nullable=False, server_default="False"),
-        sa.Column('read', sa.Boolean, nullable=False, server_default="False"),
+        "reports_groups",
+        sa.Column("id", sa.types.BigInteger, primary_key=True),
+        sa.Column(
+            "resource_id",
+            sa.Integer,
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+            nullable=False,
+        ),
+        sa.Column("priority", sa.Integer, nullable=False, server_default="5"),
+        sa.Column(
+            "first_timestamp",
+            sa.DateTime(),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column("last_timestamp", sa.DateTime()),
+        sa.Column("error", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column("grouping_hash", sa.Unicode(40), nullable=False, server_default=""),
+        sa.Column(
+            "triggered_postprocesses_ids",
+            sa.dialects.postgresql.JSON,
+            nullable=False,
+            server_default="[]",
+        ),
+        sa.Column("report_type", sa.Integer, nullable=False, server_default="0"),
+        sa.Column("total_reports", sa.Integer, nullable=False, server_default="0"),
+        sa.Column("last_report", sa.Integer, nullable=False, server_default="0"),
+        sa.Column("occurences", sa.Integer, nullable=False, server_default="1"),
+        sa.Column("average_duration", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("summed_duration", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("notified", sa.Boolean, nullable=False, server_default="False"),
+        sa.Column("fixed", sa.Boolean, nullable=False, server_default="False"),
+        sa.Column("public", sa.Boolean, nullable=False, server_default="False"),
+        sa.Column("read", sa.Boolean, nullable=False, server_default="False"),
     )
 
     op.create_table(
-        'reports',
-        sa.Column('id', sa.types.BigInteger, primary_key=True),
-        sa.Column('group_id', sa.types.BigInteger,
-                  sa.ForeignKey('reports_groups.id', onupdate='cascade',
-                                ondelete='cascade'), nullable=False, index=True),
-        sa.Column('resource_id', sa.Integer, nullable=False, index=True),
-        sa.Column('report_type', sa.Integer, nullable=False, server_default="0"),
-        sa.Column('error', sa.UnicodeText, nullable=False, server_default=""),
-        sa.Column('extra', sa.dialects.postgresql.JSON, nullable=False, server_default="{}"),
-        sa.Column('request', sa.dialects.postgresql.JSON, nullable=False, server_default="{}"),
-        sa.Column('tags', sa.dialects.postgresql.JSON, nullable=False, server_default="{}"),
-        sa.Column('ip', sa.Unicode(39), nullable=False, server_default=""),
-        sa.Column('username', sa.Unicode(255), nullable=False, server_default=""),
-        sa.Column('user_agent', sa.Unicode(512), nullable=False, server_default=""),
-        sa.Column('url', sa.UnicodeText, nullable=False, server_default=""),
-        sa.Column('request_id', sa.Unicode(40), nullable=False, server_default=""),
-        sa.Column('request_stats', sa.dialects.postgresql.JSON, nullable=False, server_default="{}"),
-        sa.Column('traceback', sa.dialects.postgresql.JSON, nullable=False, server_default="{}"),
-        sa.Column('traceback_hash', sa.Unicode(40), nullable=False, server_default=""),
-        sa.Column('start_time', sa.DateTime(), nullable=False, server_default=sa.func.now()),
-        sa.Column('end_time', sa.DateTime()),
-        sa.Column('report_group_time', sa.DateTime, index=True, nullable=False, server_default=sa.func.now()),
-        sa.Column('duration', sa.Float(), nullable=False, server_default="0"),
-        sa.Column('http_status', sa.Integer, index=True),
-        sa.Column('url_domain', sa.Unicode(128)),
-        sa.Column('url_path', sa.UnicodeText),
-        sa.Column('language', sa.Integer, server_default="0"),
-    )
-    op.create_index(None, 'reports',
-                    [sa.text("(tags ->> 'server_name')")])
-    op.create_index(None, 'reports',
-                    [sa.text("(tags ->> 'view_name')")])
+        "reports",
+        sa.Column("id", sa.types.BigInteger, primary_key=True),
+        sa.Column(
+            "group_id",
+            sa.types.BigInteger,
+            sa.ForeignKey("reports_groups.id", onupdate="cascade", ondelete="cascade"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column("resource_id", sa.Integer, nullable=False, index=True),
+        sa.Column("report_type", sa.Integer, nullable=False, server_default="0"),
+        sa.Column("error", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column(
+            "extra", sa.dialects.postgresql.JSON, nullable=False, server_default="{}"
+        ),
+        sa.Column(
+            "request", sa.dialects.postgresql.JSON, nullable=False, server_default="{}"
+        ),
+        sa.Column(
+            "tags", sa.dialects.postgresql.JSON, nullable=False, server_default="{}"
+        ),
+        sa.Column("ip", sa.Unicode(39), nullable=False, server_default=""),
+        sa.Column("username", sa.Unicode(255), nullable=False, server_default=""),
+        sa.Column("user_agent", sa.Unicode(512), nullable=False, server_default=""),
+        sa.Column("url", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column("request_id", sa.Unicode(40), nullable=False, server_default=""),
+        sa.Column(
+            "request_stats",
+            sa.dialects.postgresql.JSON,
+            nullable=False,
+            server_default="{}",
+        ),
+        sa.Column(
+            "traceback",
+            sa.dialects.postgresql.JSON,
+            nullable=False,
+            server_default="{}",
+        ),
+        sa.Column("traceback_hash", sa.Unicode(40), nullable=False, server_default=""),
+        sa.Column(
+            "start_time", sa.DateTime(), nullable=False, server_default=sa.func.now()
+        ),
+        sa.Column("end_time", sa.DateTime()),
+        sa.Column(
+            "report_group_time",
+            sa.DateTime,
+            index=True,
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column("duration", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("http_status", sa.Integer, index=True),
+        sa.Column("url_domain", sa.Unicode(128)),
+        sa.Column("url_path", sa.UnicodeText),
+        sa.Column("language", sa.Integer, server_default="0"),
+    )
+    op.create_index(None, "reports", [sa.text("(tags ->> 'server_name')")])
+    op.create_index(None, "reports", [sa.text("(tags ->> 'view_name')")])
 
     op.create_table(
-        'reports_assignments',
-        sa.Column('group_id', sa.types.BigInteger, nullable=False, primary_key=True),
-        sa.Column('owner_id', sa.Integer,
-            sa.ForeignKey('users.id', onupdate='cascade',ondelete='cascade'),
-            nullable=False, primary_key=True),
-        sa.Column('report_time', sa.DateTime, nullable=False)
+        "reports_assignments",
+        sa.Column("group_id", sa.types.BigInteger, nullable=False, primary_key=True),
+        sa.Column(
+            "owner_id",
+            sa.Integer,
+            sa.ForeignKey("users.id", onupdate="cascade", ondelete="cascade"),
+            nullable=False,
+            primary_key=True,
+        ),
+        sa.Column("report_time", sa.DateTime, nullable=False),
         )
 
     op.create_table(
-        'reports_comments',
-        sa.Column('comment_id', sa.Integer, primary_key=True),
-        sa.Column('body', sa.UnicodeText, nullable=False, server_default=''),
-        sa.Column('owner_id', sa.Integer,
-                  sa.ForeignKey('users.id', onupdate='cascade',
-                                ondelete='set null'), nullable=True),
-        sa.Column('created_timestamp', sa.DateTime, nullable=False, server_default=sa.func.now()),
-        sa.Column('report_time', sa.DateTime, nullable=False),
-        sa.Column('group_id', sa.types.BigInteger, nullable=False)
+        "reports_comments",
+        sa.Column("comment_id", sa.Integer, primary_key=True),
+        sa.Column("body", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column(
+            "owner_id",
+            sa.Integer,
+            sa.ForeignKey("users.id", onupdate="cascade", ondelete="set null"),
+            nullable=True,
+        ),
+        sa.Column(
+            "created_timestamp",
+            sa.DateTime,
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column("report_time", sa.DateTime, nullable=False),
+        sa.Column("group_id", sa.types.BigInteger, nullable=False),
     )
 
     op.create_table(
-        'reports_stats',
-        sa.Column('resource_id', sa.Integer, nullable=False, index=True),
-        sa.Column('start_interval', sa.DateTime, nullable=False, index=True),
-        sa.Column('group_id', sa.types.BigInteger, index=True),
-        sa.Column('occurences', sa.Integer, nullable=False, server_default='0', index=True),
-        sa.Column('owner_user_id', sa.Integer),
-        sa.Column('type', sa.Integer, index=True, nullable=False),
-        sa.Column('duration', sa.Float(), server_default='0'),
-        sa.Column('server_name', sa.Unicode(128),
-                  server_default=''),
-        sa.Column('view_name', sa.Unicode(128),
-                  server_default=''),
-        sa.Column('id', sa.BigInteger(), nullable=False, primary_key=True),
-    )
-    op.create_index('ix_reports_stats_start_interval_group_id', 'reports_stats',
-                    ["start_interval", "group_id"])
+        "reports_stats",
+        sa.Column("resource_id", sa.Integer, nullable=False, index=True),
+        sa.Column("start_interval", sa.DateTime, nullable=False, index=True),
+        sa.Column("group_id", sa.types.BigInteger, index=True),
+        sa.Column(
+            "occurences", sa.Integer, nullable=False, server_default="0", index=True
+        ),
+        sa.Column("owner_user_id", sa.Integer),
+        sa.Column("type", sa.Integer, index=True, nullable=False),
+        sa.Column("duration", sa.Float(), server_default="0"),
+        sa.Column("server_name", sa.Unicode(128), server_default=""),
+        sa.Column("view_name", sa.Unicode(128), server_default=""),
+        sa.Column("id", sa.BigInteger(), nullable=False, primary_key=True),
+    )
+    op.create_index(
+        "ix_reports_stats_start_interval_group_id",
+        "reports_stats",
+        ["start_interval", "group_id"],
+    )
 
     op.create_table(
-        'slow_calls',
-        sa.Column('id', sa.types.BigInteger, primary_key=True),
-        sa.Column('report_id', sa.types.BigInteger, sa.ForeignKey('reports.id', onupdate='cascade', ondelete='cascade'),
-                  nullable=False, index=True),
-        sa.Column('duration', sa.Float(), nullable=False, server_default="0", index=True),
-        sa.Column('timestamp', sa.DateTime, nullable=False, server_default=sa.func.now(), index=True),
-        sa.Column('report_group_time', sa.DateTime, index=True, nullable=False, server_default=sa.func.now()),
-        sa.Column('type', sa.Unicode(16), nullable=False, index=True),
-        sa.Column('statement', sa.UnicodeText, nullable=False, server_default=''),
-        sa.Column('parameters', sa.dialects.postgresql.JSON, nullable=False),
-        sa.Column('location', sa.UnicodeText, server_default=''),
-        sa.Column('subtype', sa.Unicode(16), nullable=False, index=True),
-        sa.Column('resource_id', sa.Integer, nullable=False, index=True),
-        sa.Column('statement_hash', sa.Unicode(60), index=True)
+        "slow_calls",
+        sa.Column("id", sa.types.BigInteger, primary_key=True),
+        sa.Column(
+            "report_id",
+            sa.types.BigInteger,
+            sa.ForeignKey("reports.id", onupdate="cascade", ondelete="cascade"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column(
+            "duration", sa.Float(), nullable=False, server_default="0", index=True
+        ),
+        sa.Column(
+            "timestamp",
+            sa.DateTime,
+            nullable=False,
+            server_default=sa.func.now(),
+            index=True,
+        ),
+        sa.Column(
+            "report_group_time",
+            sa.DateTime,
+            index=True,
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column("type", sa.Unicode(16), nullable=False, index=True),
+        sa.Column("statement", sa.UnicodeText, nullable=False, server_default=""),
+        sa.Column("parameters", sa.dialects.postgresql.JSON, nullable=False),
+        sa.Column("location", sa.UnicodeText, server_default=""),
+        sa.Column("subtype", sa.Unicode(16), nullable=False, index=True),
+        sa.Column("resource_id", sa.Integer, nullable=False, index=True),
+        sa.Column("statement_hash", sa.Unicode(60), index=True),
     )
 
     op.create_table(
-        'tags',
-        sa.Column('id', sa.types.BigInteger, primary_key=True),
-        sa.Column('resource_id', sa.Integer,
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('first_timestamp', sa.DateTime, nullable=False, server_default=sa.func.now()),
-        sa.Column('last_timestamp', sa.DateTime, nullable=False, server_default=sa.func.now()),
-        sa.Column('name', sa.Unicode(32), nullable=False),
-        sa.Column('value', sa.dialects.postgresql.JSON, nullable=False),
-        sa.Column('times_seen', sa.Integer, nullable=False, server_default='1')
+        "tags",
+        sa.Column("id", sa.types.BigInteger, primary_key=True),
+        sa.Column(
+            "resource_id",
+            sa.Integer,
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column(
+            "first_timestamp", sa.DateTime, nullable=False, server_default=sa.func.now()
+        ),
+        sa.Column(
+            "last_timestamp", sa.DateTime, nullable=False, server_default=sa.func.now()
+        ),
+        sa.Column("name", sa.Unicode(32), nullable=False),
+        sa.Column("value", sa.dialects.postgresql.JSON, nullable=False),
+        sa.Column("times_seen", sa.Integer, nullable=False, server_default="1"),
     )
 
     op.create_table(
-        'auth_tokens',
-        sa.Column('id', sa.Integer, nullable=False, primary_key=True),
-        sa.Column('token', sa.Unicode),
-        sa.Column('creation_date', sa.DateTime, nullable=False, server_default=sa.func.now()),
-        sa.Column('expires', sa.DateTime),
-        sa.Column('owner_id', sa.Integer,
-                  sa.ForeignKey('users.id', onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('description', sa.Unicode),
+        "auth_tokens",
+        sa.Column("id", sa.Integer, nullable=False, primary_key=True),
+        sa.Column("token", sa.Unicode),
+        sa.Column(
+            "creation_date", sa.DateTime, nullable=False, server_default=sa.func.now()
+        ),
+        sa.Column("expires", sa.DateTime),
+        sa.Column(
+            "owner_id",
+            sa.Integer,
+            sa.ForeignKey("users.id", onupdate="cascade", ondelete="cascade"),
+        ),
+        sa.Column("description", sa.Unicode),
     )
 
     op.create_table(
-        'channels_actions',
-        sa.Column('channel_pkey', sa.Integer,
-                  sa.ForeignKey('alert_channels.pkey',
-                                ondelete='CASCADE', onupdate='CASCADE')),
-        sa.Column('action_pkey', sa.Integer,
-                  sa.ForeignKey('alert_channels_actions.pkey',
-                                ondelete='CASCADE', onupdate='CASCADE'))
+        "channels_actions",
+        sa.Column(
+            "channel_pkey",
+            sa.Integer,
+            sa.ForeignKey(
+                "alert_channels.pkey", ondelete="CASCADE", onupdate="CASCADE"
+            ),
+        ),
+        sa.Column(
+            "action_pkey",
+            sa.Integer,
+            sa.ForeignKey(
+                "alert_channels_actions.pkey", ondelete="CASCADE", onupdate="CASCADE"
+            ),
+        ),
     )
 
     op.create_table(
-        'config',
-        sa.Column('key', sa.Unicode(128), primary_key=True),
-        sa.Column('section', sa.Unicode(128), primary_key=True),
-        sa.Column('value', sa.dialects.postgresql.JSON,
-                  server_default="{}")
+        "config",
+        sa.Column("key", sa.Unicode(128), primary_key=True),
+        sa.Column("section", sa.Unicode(128), primary_key=True),
+        sa.Column("value", sa.dialects.postgresql.JSON, server_default="{}"),
     )
 
     op.create_table(
-        'plugin_configs',
-        sa.Column('id', sa.Integer, primary_key=True),
-        sa.Column('plugin_name', sa.Unicode(128)),
-        sa.Column('section', sa.Unicode(128)),
-        sa.Column('config', sa.dialects.postgresql.JSON,
-                  server_default="{}"),
-        sa.Column('resource_id', sa.Integer(),
-                  sa.ForeignKey('resources.resource_id', onupdate='cascade',
-                                ondelete='cascade')),
-        sa.Column('owner_id', sa.Integer(),
-                  sa.ForeignKey('users.id', onupdate='cascade',
-                                ondelete='cascade')))
+        "plugin_configs",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column("plugin_name", sa.Unicode(128)),
+        sa.Column("section", sa.Unicode(128)),
+        sa.Column("config", sa.dialects.postgresql.JSON, server_default="{}"),
+        sa.Column(
+            "resource_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                "resources.resource_id", onupdate="cascade", ondelete="cascade"
+            ),
+        ),
+        sa.Column(
+            "owner_id",
+            sa.Integer(),
+            sa.ForeignKey("users.id", onupdate="cascade", ondelete="cascade"),
+        ),
+    )
 
     op.create_table(
-        'rc_versions',
-        sa.Column('name', sa.Unicode(40), primary_key=True),
-        sa.Column('value', sa.Unicode(40)),
+        "rc_versions",
+        sa.Column("name", sa.Unicode(40), primary_key=True),
+        sa.Column("value", sa.Unicode(40)),
+    )
+    version_table = sa.table(
+        "rc_versions",
+        sa.Column("name", sa.Unicode(40)),
+        sa.Column("value", sa.Unicode(40)),
     )
-    version_table = sa.table('rc_versions',
-                             sa.Column('name', sa.Unicode(40)),
-                             sa.Column('value', sa.Unicode(40)))
 
-    insert = version_table.insert().values(name='es_reports')
+    insert = version_table.insert().values(name="es_reports")
     op.execute(insert)
-    insert = version_table.insert().values(name='es_reports_groups')
+    insert = version_table.insert().values(name="es_reports_groups")
     op.execute(insert)
-    insert = version_table.insert().values(name='es_reports_stats')
+    insert = version_table.insert().values(name="es_reports_stats")
     op.execute(insert)
-    insert = version_table.insert().values(name='es_logs')
+    insert = version_table.insert().values(name="es_logs")
     op.execute(insert)
-    insert = version_table.insert().values(name='es_metrics')
+    insert = version_table.insert().values(name="es_metrics")
     op.execute(insert)
-    insert = version_table.insert().values(name='es_slow_calls')
+    insert = version_table.insert().values(name="es_slow_calls")
     op.execute(insert)
 
-
-    op.execute('''
+    op.execute(
+        """
         CREATE OR REPLACE FUNCTION floor_time_5min(timestamp without time zone)
           RETURNS timestamp without time zone AS
         $BODY$SELECT date_trunc('hour', $1) + INTERVAL '5 min' * FLOOR(date_part('minute', $1) / 5.0)$BODY$
           LANGUAGE sql VOLATILE;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE OR REPLACE FUNCTION partition_logs() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -426,13 +592,17 b' def upgrade():'
     RETURN NULL;
     END
     $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_logs BEFORE INSERT ON logs FOR EACH ROW EXECUTE PROCEDURE partition_logs();
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE OR REPLACE FUNCTION partition_metrics() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -463,13 +633,17 b' def upgrade():'
     RETURN NULL;
     END
     $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_metrics BEFORE INSERT ON metrics FOR EACH ROW EXECUTE PROCEDURE partition_metrics();
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE FUNCTION partition_reports_stats() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -499,13 +673,17 b' def upgrade():'
             RETURN NULL;
         END
         $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_reports_stats BEFORE INSERT ON reports_stats FOR EACH ROW EXECUTE PROCEDURE partition_reports_stats();
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE OR REPLACE FUNCTION partition_reports_groups() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -533,13 +711,17 b' def upgrade():'
         RETURN NULL;
     END
     $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_reports_groups BEFORE INSERT ON reports_groups FOR EACH ROW EXECUTE PROCEDURE partition_reports_groups();
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE OR REPLACE FUNCTION partition_reports() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -573,14 +755,17 b' def upgrade():'
         RETURN NULL;
     END
     $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_reports BEFORE INSERT ON reports FOR EACH ROW EXECUTE PROCEDURE partition_reports();
-    ''')
-
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE OR REPLACE FUNCTION partition_slow_calls() RETURNS trigger
         LANGUAGE plpgsql SECURITY DEFINER
         AS $$
@@ -614,11 +799,15 b' def upgrade():'
         RETURN NULL;
     END
     $$;
-    ''')
+    """
+    )
 
-    op.execute('''
+    op.execute(
+        """
     CREATE TRIGGER partition_slow_calls BEFORE INSERT ON slow_calls FOR EACH ROW EXECUTE PROCEDURE partition_slow_calls();
-    ''')
+    """
+    )
+
 
 def downgrade():
     pass

backend/src/appenlight/migrations/versions/e9fcfbdd9498_connect_resources_to_alert_channels.py

@@ -7,8 +7,8 b' Create Date: 2018-02-28 13:52:50.717217'
 """
 
 # revision identifiers, used by Alembic.
-revision = 'e9fcfbdd9498'
-down_revision = '55b6e612672f'
+revision = "e9fcfbdd9498"
+down_revision = "55b6e612672f"
 
 from alembic import op
 import sqlalchemy as sa
@@ -16,17 +16,25 b' import sqlalchemy as sa'
 
 def upgrade():
     op.create_table(
-        'channels_resources',
-        sa.Column('channel_pkey', sa.Integer,
-                  sa.ForeignKey('alert_channels.pkey',
-                                ondelete='CASCADE', onupdate='CASCADE'),
-                  primary_key=True),
-        sa.Column('resource_id', sa.Integer,
-                  sa.ForeignKey('resources.resource_id',
-                                ondelete='CASCADE', onupdate='CASCADE'),
-                  primary_key=True)
+        "channels_resources",
+        sa.Column(
+            "channel_pkey",
+            sa.Integer,
+            sa.ForeignKey(
+                "alert_channels.pkey", ondelete="CASCADE", onupdate="CASCADE"
+            ),
+            primary_key=True,
+        ),
+        sa.Column(
+            "resource_id",
+            sa.Integer,
+            sa.ForeignKey(
+                "resources.resource_id", ondelete="CASCADE", onupdate="CASCADE"
+            ),
+            primary_key=True,
+        ),
     )
 
 
 def downgrade():
-    op.drop_table('channels_resources')
+    op.drop_table("channels_resources")

backend/src/appenlight/models/__init__.py

@@ -29,11 +29,11 b' log = logging.getLogger(__name__)'
 DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
 
 NAMING_CONVENTION = {
-    "ix": 'ix_%(column_0_label)s',
+    "ix": "ix_%(column_0_label)s",
     "uq": "uq_%(table_name)s_%(column_0_name)s",
     "ck": "ck_%(table_name)s_%(constraint_name)s",
     "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
-    "pk": "pk_%(table_name)s"
+    "pk": "pk_%(table_name)s",
 }
 
 metadata = MetaData(naming_convention=NAMING_CONVENTION)
@@ -59,23 +59,24 b' class SliceableESQuery(object):'
         self.query = query
         self.sort_query = sort_query
         self.aggregations = aggregations
-        self.items_per_page = kwconfig.pop('items_per_page', 10)
-        self.page = kwconfig.pop('page', 1)
+        self.items_per_page = kwconfig.pop("items_per_page", 10)
+        self.page = kwconfig.pop("page", 1)
         self.kwconfig = kwconfig
         self.result = None
 
     def __getitem__(self, index):
         config = self.kwconfig.copy()
-        config['from_'] = index.start
+        config["from_"] = index.start
         query = self.query.copy()
         if self.sort_query:
             query.update(self.sort_query)
-        self.result = Datastores.es.search(body=query, size=self.items_per_page,
-                                           **config)
+        self.result = Datastores.es.search(
+            body=query, size=self.items_per_page, **config
+        )
         if self.aggregations:
-            self.items = self.result.get('aggregations')
+            self.items = self.result.get("aggregations")
         else:
-            self.items = self.result['hits']['hits']
+            self.items = self.result["hits"]["hits"]
 
         return self.items
 
@@ -85,14 +86,15 b' class SliceableESQuery(object):'
     def __len__(self):
         config = self.kwconfig.copy()
         query = self.query.copy()
-        self.result = Datastores.es.search(body=query, size=self.items_per_page,
-                                           **config)
+        self.result = Datastores.es.search(
+            body=query, size=self.items_per_page, **config
+        )
         if self.aggregations:
-            self.items = self.result.get('aggregations')
+            self.items = self.result.get("aggregations")
         else:
-            self.items = self.result['hits']['hits']
+            self.items = self.result["hits"]["hits"]
 
-        count = int(self.result['hits']['total'])
+        count = int(self.result["hits"]["total"])
         return count if count < 5000 else 5000
 
 
@@ -102,8 +104,7 b' from appenlight.models.user import User'
 from appenlight.models.alert_channel import AlertChannel
 from appenlight.models.alert_channel_action import AlertChannelAction
 from appenlight.models.metric import Metric
-from appenlight.models.application_postprocess_conf import \
-    ApplicationPostprocessConf
+from appenlight.models.application_postprocess_conf import ApplicationPostprocessConf
 from appenlight.models.auth_token import AuthToken
 from appenlight.models.event import Event
 from appenlight.models.external_identity import ExternalIdentity
@@ -124,7 +125,15 b' from appenlight.models.user_permission import UserPermission'
 from appenlight.models.user_resource_permission import UserResourcePermission
 from ziggurat_foundations import ziggurat_model_init
 
-ziggurat_model_init(User, Group, UserGroup, GroupPermission, UserPermission,
-                    UserResourcePermission, GroupResourcePermission,
+ziggurat_model_init(
+    User,
+    Group,
+    UserGroup,
+    GroupPermission,
+    UserPermission,
+    UserResourcePermission,
+    GroupResourcePermission,
                     Resource,
-                    ExternalIdentity, passwordmanager=None)
+    ExternalIdentity,
+    passwordmanager=None,
+)

backend/src/appenlight/models/alert_channel.py

@@ -27,126 +27,125 b' log = logging.getLogger(__name__)'
 
 #
 channel_rules_m2m_table = sa.Table(
-    'channels_actions', Base.metadata,
-    sa.Column('channel_pkey', sa.Integer,
-              sa.ForeignKey('alert_channels.pkey')),
-    sa.Column('action_pkey', sa.Integer,
-              sa.ForeignKey('alert_channels_actions.pkey'))
+    "channels_actions",
+    Base.metadata,
+    sa.Column("channel_pkey", sa.Integer, sa.ForeignKey("alert_channels.pkey")),
+    sa.Column("action_pkey", sa.Integer, sa.ForeignKey("alert_channels_actions.pkey")),
 )
 
 channel_resources_m2m_table = sa.Table(
-    'channels_resources', Base.metadata,
-    sa.Column('channel_pkey', sa.Integer,
-              sa.ForeignKey('alert_channels.pkey')),
-    sa.Column('resource_id', sa.Integer,
-              sa.ForeignKey('resources.resource_id'))
+    "channels_resources",
+    Base.metadata,
+    sa.Column("channel_pkey", sa.Integer, sa.ForeignKey("alert_channels.pkey")),
+    sa.Column("resource_id", sa.Integer, sa.ForeignKey("resources.resource_id")),
 )
 
-DATE_FRMT = '%Y-%m-%dT%H:%M'
+DATE_FRMT = "%Y-%m-%dT%H:%M"
 
 
 class AlertChannel(Base, BaseModel):
     """
     Stores information about possible alerting options
     """
-    __tablename__ = 'alert_channels'
-    __possible_channel_names__ = ['email']
+
+    __tablename__ = "alert_channels"
+    __possible_channel_names__ = ["email"]
     __mapper_args__ = {
-        'polymorphic_on': 'channel_name',
-        'polymorphic_identity': 'integration'
+        "polymorphic_on": "channel_name",
+        "polymorphic_identity": "integration",
     }
 
-    owner_id = sa.Column(sa.Unicode(30),
-                         sa.ForeignKey('users.id', onupdate='CASCADE',
-                                       ondelete='CASCADE'))
+    owner_id = sa.Column(
+        sa.Unicode(30),
+        sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE"),
+    )
     channel_name = sa.Column(sa.Unicode(25), nullable=False)
-    channel_value = sa.Column(sa.Unicode(80), nullable=False, default='')
-    channel_json_conf = sa.Column(JSON(), nullable=False, default='')
-    channel_validated = sa.Column(sa.Boolean, nullable=False,
-                                  default=False)
-    send_alerts = sa.Column(sa.Boolean, nullable=False,
-                            default=True)
-    daily_digest = sa.Column(sa.Boolean, nullable=False,
-                             default=True)
-    integration_id = sa.Column(sa.Integer, sa.ForeignKey('integrations.id'),
-                               nullable=True)
+    channel_value = sa.Column(sa.Unicode(80), nullable=False, default="")
+    channel_json_conf = sa.Column(JSON(), nullable=False, default="")
+    channel_validated = sa.Column(sa.Boolean, nullable=False, default=False)
+    send_alerts = sa.Column(sa.Boolean, nullable=False, default=True)
+    daily_digest = sa.Column(sa.Boolean, nullable=False, default=True)
+    integration_id = sa.Column(
+        sa.Integer, sa.ForeignKey("integrations.id"), nullable=True
+    )
     pkey = sa.Column(sa.Integer(), nullable=False, primary_key=True)
 
-    channel_actions = sa.orm.relationship('AlertChannelAction',
+    channel_actions = sa.orm.relationship(
+        "AlertChannelAction",
                                           cascade="all",
                                           passive_deletes=True,
                                           passive_updates=True,
                                           secondary=channel_rules_m2m_table,
-                                          backref='channels')
-    resources = sa.orm.relationship('Resource',
+        backref="channels",
+    )
+    resources = sa.orm.relationship(
+        "Resource",
                                     cascade="all",
                                     passive_deletes=True,
                                     passive_updates=True,
                                     secondary=channel_resources_m2m_table,
-                                    backref='resources')
+        backref="resources",
+    )
 
     @property
     def channel_visible_value(self):
         if self.integration:
-            return '{}: {}'.format(
-                self.channel_name,
-                self.integration.resource.resource_name
+            return "{}: {}".format(
+                self.channel_name, self.integration.resource.resource_name
             )
 
-        return '{}: {}'.format(
-            self.channel_name,
-            self.channel_value
-        )
+        return "{}: {}".format(self.channel_name, self.channel_value)
 
-    def get_dict(self, exclude_keys=None, include_keys=None,
-                 extended_info=True):
+    def get_dict(self, exclude_keys=None, include_keys=None, extended_info=True):
         """
         Returns dictionary with required information that will be consumed by
         angular
         """
-        instance_dict = super(AlertChannel, self).get_dict(exclude_keys,
-                                                           include_keys)
+        instance_dict = super(AlertChannel, self).get_dict(exclude_keys, include_keys)
         exclude_keys_list = exclude_keys or []
         include_keys_list = include_keys or []
 
-        instance_dict['supports_report_alerting'] = True
-        instance_dict['channel_visible_value'] = self.channel_visible_value
+        instance_dict["supports_report_alerting"] = True
+        instance_dict["channel_visible_value"] = self.channel_visible_value
 
         if extended_info:
-            instance_dict['actions'] = [
-                rule.get_dict(extended_info=True) for
-                rule in self.channel_actions]
+            instance_dict["actions"] = [
+                rule.get_dict(extended_info=True) for rule in self.channel_actions
+            ]
 
-        del instance_dict['channel_json_conf']
+        del instance_dict["channel_json_conf"]
 
         if self.integration:
             instance_dict[
-                'supports_report_alerting'] = \
-                self.integration.supports_report_alerting
+                "supports_report_alerting"
+            ] = self.integration.supports_report_alerting
         d = {}
         for k in instance_dict.keys():
-            if (k not in exclude_keys_list and
-                    (k in include_keys_list or not include_keys)):
+            if k not in exclude_keys_list and (
+                k in include_keys_list or not include_keys
+            ):
                 d[k] = instance_dict[k]
         return d
 
     def __repr__(self):
-        return '<AlertChannel: (%s,%s), user:%s>' % (self.channel_name,
+        return "<AlertChannel: (%s,%s), user:%s>" % (
+            self.channel_name,
                                                      self.channel_value,
-                                                     self.user_name,)
+            self.user_name,
+        )
 
     def send_digest(self, **kwargs):
         """
         This should implement daily top error report notifications
         """
-        log.warning('send_digest NOT IMPLEMENTED')
+        log.warning("send_digest NOT IMPLEMENTED")
 
     def notify_reports(self, **kwargs):
         """
         This should implement notification of reports that occured in 1 min
         interval
         """
-        log.warning('notify_reports NOT IMPLEMENTED')
+        log.warning("notify_reports NOT IMPLEMENTED")
 
     def notify_alert(self, **kwargs):
         """
@@ -160,87 +159,85 b' class AlertChannel(Base, BaseModel):'
             request: request object
 
         """
-        alert_name = kwargs['event'].unified_alert_name()
-        if alert_name in ['slow_report_alert', 'error_report_alert']:
+        alert_name = kwargs["event"].unified_alert_name()
+        if alert_name in ["slow_report_alert", "error_report_alert"]:
             self.notify_report_alert(**kwargs)
-        elif alert_name == 'uptime_alert':
+        elif alert_name == "uptime_alert":
             self.notify_uptime_alert(**kwargs)
-        elif alert_name == 'chart_alert':
+        elif alert_name == "chart_alert":
             self.notify_chart_alert(**kwargs)
 
     def notify_chart_alert(self, **kwargs):
         """
         This should implement report open/close alerts notifications
         """
-        log.warning('notify_chart_alert NOT IMPLEMENTED')
+        log.warning("notify_chart_alert NOT IMPLEMENTED")
 
     def notify_report_alert(self, **kwargs):
         """
         This should implement report open/close alerts notifications
         """
-        log.warning('notify_report_alert NOT IMPLEMENTED')
+        log.warning("notify_report_alert NOT IMPLEMENTED")
 
     def notify_uptime_alert(self, **kwargs):
         """
         This should implement uptime open/close alerts notifications
         """
-        log.warning('notify_uptime_alert NOT IMPLEMENTED')
+        log.warning("notify_uptime_alert NOT IMPLEMENTED")
 
     def get_notification_basic_vars(self, kwargs):
         """
         Sets most common variables used later for rendering notifications for
         channel
         """
-        if 'event' in kwargs:
-            kwargs['since_when'] = kwargs['event'].start_date
+        if "event" in kwargs:
+            kwargs["since_when"] = kwargs["event"].start_date
 
-        url_start_date = kwargs.get('since_when') - timedelta(minutes=1)
-        url_end_date = kwargs.get('since_when') + timedelta(minutes=4)
+        url_start_date = kwargs.get("since_when") - timedelta(minutes=1)
+        url_end_date = kwargs.get("since_when") + timedelta(minutes=4)
         tmpl_vars = {
-            "timestamp": kwargs['since_when'],
-            "user": kwargs['user'],
-            "since_when": kwargs.get('since_when'),
+            "timestamp": kwargs["since_when"],
+            "user": kwargs["user"],
+            "since_when": kwargs.get("since_when"),
             "url_start_date": url_start_date,
-            "url_end_date": url_end_date
+            "url_end_date": url_end_date,
         }
-        tmpl_vars["resource_name"] = kwargs['resource'].resource_name
-        tmpl_vars["resource"] = kwargs['resource']
+        tmpl_vars["resource_name"] = kwargs["resource"].resource_name
+        tmpl_vars["resource"] = kwargs["resource"]
 
-        if 'event' in kwargs:
-            tmpl_vars['event_values'] = kwargs['event'].values
-            tmpl_vars['alert_type'] = kwargs['event'].unified_alert_name()
-            tmpl_vars['alert_action'] = kwargs['event'].unified_alert_action()
+        if "event" in kwargs:
+            tmpl_vars["event_values"] = kwargs["event"].values
+            tmpl_vars["alert_type"] = kwargs["event"].unified_alert_name()
+            tmpl_vars["alert_action"] = kwargs["event"].unified_alert_action()
         return tmpl_vars
 
     def report_alert_notification_vars(self, kwargs):
         tmpl_vars = self.get_notification_basic_vars(kwargs)
-        reports = kwargs.get('reports', [])
+        reports = kwargs.get("reports", [])
         tmpl_vars["reports"] = reports
         tmpl_vars["confirmed_total"] = len(reports)
 
         tmpl_vars["report_type"] = "error reports"
-        tmpl_vars["url_report_type"] = 'report/list'
+        tmpl_vars["url_report_type"] = "report/list"
 
-        alert_type = tmpl_vars.get('alert_type', '')
-        if 'slow_report' in alert_type:
+        alert_type = tmpl_vars.get("alert_type", "")
+        if "slow_report" in alert_type:
             tmpl_vars["report_type"] = "slow reports"
-            tmpl_vars["url_report_type"] = 'report/list_slow'
+            tmpl_vars["url_report_type"] = "report/list_slow"
 
-        app_url = kwargs['request'].registry.settings['_mail_url']
+        app_url = kwargs["request"].registry.settings["_mail_url"]
 
-        destination_url = kwargs['request'].route_url('/',
-                                                      _app_url=app_url)
+        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
         if alert_type:
-            destination_url += 'ui/{}?resource={}&start_date={}&end_date={}'.format(
+            destination_url += "ui/{}?resource={}&start_date={}&end_date={}".format(
                 tmpl_vars["url_report_type"],
-                tmpl_vars['resource'].resource_id,
-                tmpl_vars['url_start_date'].strftime(DATE_FRMT),
-                tmpl_vars['url_end_date'].strftime(DATE_FRMT)
+                tmpl_vars["resource"].resource_id,
+                tmpl_vars["url_start_date"].strftime(DATE_FRMT),
+                tmpl_vars["url_end_date"].strftime(DATE_FRMT),
             )
         else:
-            destination_url += 'ui/{}?resource={}'.format(
-                tmpl_vars["url_report_type"],
-                tmpl_vars['resource'].resource_id
+            destination_url += "ui/{}?resource={}".format(
+                tmpl_vars["url_report_type"], tmpl_vars["resource"].resource_id
             )
         tmpl_vars["destination_url"] = destination_url
 
@@ -248,58 +245,54 b' class AlertChannel(Base, BaseModel):'
 
     def uptime_alert_notification_vars(self, kwargs):
         tmpl_vars = self.get_notification_basic_vars(kwargs)
-        app_url = kwargs['request'].registry.settings['_mail_url']
-        destination_url = kwargs['request'].route_url('/', _app_url=app_url)
-        destination_url += 'ui/{}?resource={}'.format(
-            'uptime',
-            tmpl_vars['resource'].resource_id)
-        tmpl_vars['destination_url'] = destination_url
-
-        reason = ''
-        e_values = tmpl_vars.get('event_values')
-
-        if e_values and e_values.get('response_time') == 0:
-            reason += ' Response time was slower than 20 seconds.'
+        app_url = kwargs["request"].registry.settings["_mail_url"]
+        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
+        destination_url += "ui/{}?resource={}".format(
+            "uptime", tmpl_vars["resource"].resource_id
+        )
+        tmpl_vars["destination_url"] = destination_url
+
+        reason = ""
+        e_values = tmpl_vars.get("event_values")
+
+        if e_values and e_values.get("response_time") == 0:
+            reason += " Response time was slower than 20 seconds."
         elif e_values:
-            code = e_values.get('status_code')
-            reason += ' Response status code: %s.' % code
+            code = e_values.get("status_code")
+            reason += " Response status code: %s." % code
 
-        tmpl_vars['reason'] = reason
+        tmpl_vars["reason"] = reason
         return tmpl_vars
 
     def chart_alert_notification_vars(self, kwargs):
         tmpl_vars = self.get_notification_basic_vars(kwargs)
-        tmpl_vars['chart_name'] = tmpl_vars['event_values']['chart_name']
-        tmpl_vars['action_name'] = tmpl_vars['event_values'].get(
-            'action_name') or ''
-        matched_values = tmpl_vars['event_values']['matched_step_values']
-        tmpl_vars['readable_values'] = []
-        for key, value in list(matched_values['values'].items()):
-            matched_label = matched_values['labels'].get(key)
+        tmpl_vars["chart_name"] = tmpl_vars["event_values"]["chart_name"]
+        tmpl_vars["action_name"] = tmpl_vars["event_values"].get("action_name") or ""
+        matched_values = tmpl_vars["event_values"]["matched_step_values"]
+        tmpl_vars["readable_values"] = []
+        for key, value in list(matched_values["values"].items()):
+            matched_label = matched_values["labels"].get(key)
             if matched_label:
-                tmpl_vars['readable_values'].append({
-                    'label': matched_label['human_label'],
-                    'value': value
-                })
-        tmpl_vars['readable_values'] = sorted(tmpl_vars['readable_values'],
-                                              key=lambda x: x['label'])
-        start_date = convert_date(tmpl_vars['event_values']['start_interval'])
+                tmpl_vars["readable_values"].append(
+                    {"label": matched_label["human_label"], "value": value}
+                )
+        tmpl_vars["readable_values"] = sorted(
+            tmpl_vars["readable_values"], key=lambda x: x["label"]
+        )
+        start_date = convert_date(tmpl_vars["event_values"]["start_interval"])
         end_date = None
-        if tmpl_vars['event_values'].get('end_interval'):
-            end_date = convert_date(tmpl_vars['event_values']['end_interval'])
+        if tmpl_vars["event_values"].get("end_interval"):
+            end_date = convert_date(tmpl_vars["event_values"]["end_interval"])
 
-        app_url = kwargs['request'].registry.settings['_mail_url']
-        destination_url = kwargs['request'].route_url('/', _app_url=app_url)
+        app_url = kwargs["request"].registry.settings["_mail_url"]
+        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
         to_encode = {
-            'resource': tmpl_vars['event_values']['resource'],
-            'start_date': start_date.strftime(DATE_FRMT),
+            "resource": tmpl_vars["event_values"]["resource"],
+            "start_date": start_date.strftime(DATE_FRMT),
         }
         if end_date:
-            to_encode['end_date'] = end_date.strftime(DATE_FRMT)
+            to_encode["end_date"] = end_date.strftime(DATE_FRMT)
 
-        destination_url += 'ui/{}?{}'.format(
-            'logs',
-            urllib.parse.urlencode(to_encode)
-        )
-        tmpl_vars['destination_url'] = destination_url
+        destination_url += "ui/{}?{}".format("logs", urllib.parse.urlencode(to_encode))
+        tmpl_vars["destination_url"] = destination_url
         return tmpl_vars

backend/src/appenlight/models/alert_channel_action.py

@@ -27,39 +27,42 b' class AlertChannelAction(Base, BaseModel):'
     Stores notifications conditions for user's alert channels
     This is later used for rule parsing like "alert if http_status == 500"
     """
-    __tablename__ = 'alert_channels_actions'
 
-    types = ['report', 'chart']
+    __tablename__ = "alert_channels_actions"
 
-    owner_id = sa.Column(sa.Integer,
-                         sa.ForeignKey('users.id', onupdate='CASCADE',
-                                       ondelete='CASCADE'))
+    types = ["report", "chart"]
+
+    owner_id = sa.Column(
+        sa.Integer, sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE")
+    )
     resource_id = sa.Column(sa.Integer())
-    action = sa.Column(sa.Unicode(10), nullable=False, default='always')
+    action = sa.Column(sa.Unicode(10), nullable=False, default="always")
     type = sa.Column(sa.Unicode(10), nullable=False)
     other_id = sa.Column(sa.Unicode(40))
     pkey = sa.Column(sa.Integer(), nullable=False, primary_key=True)
-    rule = sa.Column(sa.dialects.postgresql.JSON,
-                     nullable=False, default={'field': 'http_status',
-                                              "op": "ge", "value": "500"})
+    rule = sa.Column(
+        sa.dialects.postgresql.JSON,
+        nullable=False,
+        default={"field": "http_status", "op": "ge", "value": "500"},
+    )
     config = sa.Column(sa.dialects.postgresql.JSON)
     name = sa.Column(sa.Unicode(255))
 
-    @validates('notify_type')
+    @validates("notify_type")
     def validate_email(self, key, notify_type):
-        assert notify_type in ['always', 'only_first']
+        assert notify_type in ["always", "only_first"]
         return notify_type
 
     def resource_name(self, db_session=None):
         db_session = get_db_session(db_session)
         if self.resource_id:
             return ResourceService.by_resource_id(
-                self.resource_id, db_session=db_session).resource_name
+                self.resource_id, db_session=db_session
+            ).resource_name
         else:
-            return 'any resource'
+            return "any resource"
 
-    def get_dict(self, exclude_keys=None, include_keys=None,
-                 extended_info=False):
+    def get_dict(self, exclude_keys=None, include_keys=None, extended_info=False):
         """
         Returns dictionary with required information that will be consumed by
         angular
@@ -68,12 +71,14 b' class AlertChannelAction(Base, BaseModel):'
         exclude_keys_list = exclude_keys or []
         include_keys_list = include_keys or []
         if extended_info:
-            instance_dict['channels'] = [
-                c.get_dict(extended_info=False) for c in self.channels]
+            instance_dict["channels"] = [
+                c.get_dict(extended_info=False) for c in self.channels
+            ]
 
         d = {}
         for k in instance_dict.keys():
-            if (k not in exclude_keys_list and
-                    (k in include_keys_list or not include_keys)):
+            if k not in exclude_keys_list and (
+                k in include_keys_list or not include_keys
+            ):
                 d[k] = instance_dict[k]
         return d

backend/src/appenlight/models/alert_channels/__init__.py

@@ -13,4 +13,3 b''
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-

backend/src/appenlight/models/alert_channels/campfire.py

@@ -23,15 +23,13 b' log = logging.getLogger(__name__)'
 
 
 class CampfireAlertChannel(AlertChannel):
-    __mapper_args__ = {
-        'polymorphic_identity': 'campfire'
-    }
+    __mapper_args__ = {"polymorphic_identity": "campfire"}
 
     @property
     def client(self):
         client = CampfireIntegration.create_client(
-            self.integration.config['api_token'],
-            self.integration.config['account'])
+            self.integration.config["api_token"], self.integration.config["account"]
+        )
         return client
 
     def notify_reports(self, **kwargs):
@@ -48,37 +46,40 b' class CampfireAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        app_url = kwargs['request'].registry.settings['_mail_url']
-        destination_url = kwargs['request'].route_url('/',
-                                                      app_url=app_url)
-        f_args = ('report',
-                  template_vars['resource'].resource_id,
-                  template_vars['url_start_date'].strftime('%Y-%m-%dT%H:%M'),
-                  template_vars['url_end_date'].strftime('%Y-%m-%dT%H:%M'))
-        destination_url += 'ui/{}?resource={}&start_date={}&end_date={}'.format(
-            *f_args)
-
-        if template_vars['confirmed_total'] > 1:
+        app_url = kwargs["request"].registry.settings["_mail_url"]
+        destination_url = kwargs["request"].route_url("/", app_url=app_url)
+        f_args = (
+            "report",
+            template_vars["resource"].resource_id,
+            template_vars["url_start_date"].strftime("%Y-%m-%dT%H:%M"),
+            template_vars["url_end_date"].strftime("%Y-%m-%dT%H:%M"),
+        )
+        destination_url += "ui/{}?resource={}&start_date={}&end_date={}".format(*f_args)
+
+        if template_vars["confirmed_total"] > 1:
             template_vars["title"] = "%s - %s reports" % (
-                template_vars['resource_name'],
-                template_vars['confirmed_total'],
+                template_vars["resource_name"],
+                template_vars["confirmed_total"],
             )
         else:
-            error_title = truncate(template_vars['reports'][0][1].error or
-                                   'slow report', 90)
+            error_title = truncate(
+                template_vars["reports"][0][1].error or "slow report", 90
+            )
             template_vars["title"] = "%s - '%s' report" % (
-                template_vars['resource_name'],
-                error_title)
+                template_vars["resource_name"],
+                error_title,
+            )
 
-        template_vars["title"] += ' ' + destination_url
+        template_vars["title"] += " " + destination_url
 
-        log_msg = 'NOTIFY  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "NOTIFY  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
-        for room in self.integration.config['rooms'].split(','):
+        for room in self.integration.config["rooms"].split(","):
             self.client.speak_to_room(room.strip(), template_vars["title"])
 
     def notify_report_alert(self, **kwargs):
@@ -94,23 +95,23 b' class CampfireAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if kwargs['event'].unified_alert_action() == 'OPEN':
-            title = 'ALERT %s: %s - %s %s %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                kwargs['event'].values['reports'],
-                template_vars['report_type'],
-                template_vars['destination_url']
+        if kwargs["event"].unified_alert_action() == "OPEN":
+            title = "ALERT %s: %s - %s %s %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                kwargs["event"].values["reports"],
+                template_vars["report_type"],
+                template_vars["destination_url"],
             )
 
         else:
-            title = 'ALERT %s: %s type: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                template_vars['alert_type'].replace('_', ' '),
+            title = "ALERT %s: %s type: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                template_vars["alert_type"].replace("_", " "),
             )
-        for room in self.integration.config['rooms'].split(','):
-            self.client.speak_to_room(room.strip(), title, sound='VUVUZELA')
+        for room in self.integration.config["rooms"].split(","):
+            self.client.speak_to_room(room.strip(), title, sound="VUVUZELA")
 
     def notify_uptime_alert(self, **kwargs):
         """
@@ -125,15 +126,15 b' class CampfireAlertChannel(AlertChannel):'
         """
         template_vars = self.uptime_alert_notification_vars(kwargs)
 
-        message = 'ALERT %s: %s has uptime issues %s\n\n' % (
-            template_vars['alert_action'],
-            template_vars['resource_name'],
-            template_vars['destination_url']
+        message = "ALERT %s: %s has uptime issues %s\n\n" % (
+            template_vars["alert_action"],
+            template_vars["resource_name"],
+            template_vars["destination_url"],
         )
-        message += template_vars['reason']
+        message += template_vars["reason"]
 
-        for room in self.integration.config['rooms'].split(','):
-            self.client.speak_to_room(room.strip(), message, sound='VUVUZELA')
+        for room in self.integration.config["rooms"].split(","):
+            self.client.speak_to_room(room.strip(), message, sound="VUVUZELA")
 
     def send_digest(self, **kwargs):
         """
@@ -148,17 +149,17 b' class CampfireAlertChannel(AlertChannel):'
 
         """
         template_vars = self.report_alert_notification_vars(kwargs)
-        f_args = (template_vars['resource_name'],
-                  template_vars['confirmed_total'],)
+        f_args = (template_vars["resource_name"], template_vars["confirmed_total"])
         message = "Daily report digest: %s - %s reports" % f_args
-        message += '{}\n'.format(template_vars['destination_url'])
-        for room in self.integration.config['rooms'].split(','):
+        message += "{}\n".format(template_vars["destination_url"])
+        for room in self.integration.config["rooms"].split(","):
             self.client.speak_to_room(room.strip(), message)
 
-        log_msg = 'DIGEST  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "DIGEST  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
     def notify_chart_alert(self, **kwargs):
@@ -173,16 +174,18 b' class CampfireAlertChannel(AlertChannel):'
 
         """
         template_vars = self.chart_alert_notification_vars(kwargs)
-        message = 'ALERT {}: value in "{}" chart: ' \
+        message = (
+            'ALERT {}: value in "{}" chart: '
                   'met alert "{}" criteria {} \n'.format(
-            template_vars['alert_action'],
-            template_vars['chart_name'],
-            template_vars['action_name'],
-            template_vars['destination_url']
+                template_vars["alert_action"],
+                template_vars["chart_name"],
+                template_vars["action_name"],
+                template_vars["destination_url"],
+            )
         )
 
-        for item in template_vars['readable_values']:
-            message += '{}: {}\n'.format(item['label'], item['value'])
+        for item in template_vars["readable_values"]:
+            message += "{}: {}\n".format(item["label"], item["value"])
 
-        for room in self.integration.config['rooms'].split(','):
-            self.client.speak_to_room(room.strip(), message, sound='VUVUZELA')
+        for room in self.integration.config["rooms"].split(","):
+            self.client.speak_to_room(room.strip(), message, sound="VUVUZELA")

backend/src/appenlight/models/alert_channels/email.py

@@ -27,9 +27,7 b' class EmailAlertChannel(AlertChannel):'
     Default email alerting channel
     """
 
-    __mapper_args__ = {
-        'polymorphic_identity': 'email'
-    }
+    __mapper_args__ = {"polymorphic_identity": "email"}
 
     def notify_reports(self, **kwargs):
         """
@@ -45,25 +43,30 b' class EmailAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if template_vars['confirmed_total'] > 1:
+        if template_vars["confirmed_total"] > 1:
             template_vars["title"] = "AppEnlight :: %s - %s reports" % (
-                template_vars['resource_name'],
-                template_vars['confirmed_total'],
+                template_vars["resource_name"],
+                template_vars["confirmed_total"],
             )
         else:
-            error_title = truncate(template_vars['reports'][0][1].error or
-                                   'slow report', 20)
+            error_title = truncate(
+                template_vars["reports"][0][1].error or "slow report", 20
+            )
             template_vars["title"] = "AppEnlight :: %s - '%s' report" % (
-                template_vars['resource_name'],
-                error_title)
-        UserService.send_email(kwargs['request'],
+                template_vars["resource_name"],
+                error_title,
+            )
+        UserService.send_email(
+            kwargs["request"],
                                [self.channel_value],
                                template_vars,
-                               '/email_templates/notify_reports.jinja2')
-        log_msg = 'NOTIFY  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+            "/email_templates/notify_reports.jinja2",
+        )
+        log_msg = "NOTIFY  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
     def send_digest(self, **kwargs):
@@ -81,20 +84,23 b' class EmailAlertChannel(AlertChannel):'
         template_vars = self.report_alert_notification_vars(kwargs)
         title = "AppEnlight :: Daily report digest: %s - %s reports"
         template_vars["email_title"] = title % (
-            template_vars['resource_name'],
-            template_vars['confirmed_total'],
+            template_vars["resource_name"],
+            template_vars["confirmed_total"],
         )
 
-        UserService.send_email(kwargs['request'],
+        UserService.send_email(
+            kwargs["request"],
                                [self.channel_value],
                                template_vars,
-                               '/email_templates/notify_reports.jinja2',
+            "/email_templates/notify_reports.jinja2",
                                immediately=True,
-                               silent=True)
-        log_msg = 'DIGEST  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+            silent=True,
+        )
+        log_msg = "DIGEST  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
     def notify_report_alert(self, **kwargs):
@@ -110,23 +116,26 b' class EmailAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if kwargs['event'].unified_alert_action() == 'OPEN':
-            title = 'AppEnlight :: ALERT %s: %s - %s %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                kwargs['event'].values['reports'],
-                template_vars['report_type'],
+        if kwargs["event"].unified_alert_action() == "OPEN":
+            title = "AppEnlight :: ALERT %s: %s - %s %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                kwargs["event"].values["reports"],
+                template_vars["report_type"],
             )
         else:
-            title = 'AppEnlight :: ALERT %s: %s type: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                template_vars['alert_type'].replace('_', ' '),
+            title = "AppEnlight :: ALERT %s: %s type: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                template_vars["alert_type"].replace("_", " "),
             )
-        template_vars['email_title'] = title
-        UserService.send_email(kwargs['request'], [self.channel_value],
+        template_vars["email_title"] = title
+        UserService.send_email(
+            kwargs["request"],
+            [self.channel_value],
                                template_vars,
-                               '/email_templates/alert_reports.jinja2')
+            "/email_templates/alert_reports.jinja2",
+        )
 
     def notify_uptime_alert(self, **kwargs):
         """
@@ -140,15 +149,18 b' class EmailAlertChannel(AlertChannel):'
 
         """
         template_vars = self.uptime_alert_notification_vars(kwargs)
-        title = 'AppEnlight :: ALERT %s: %s has uptime issues' % (
-            template_vars['alert_action'],
-            template_vars['resource_name'],
+        title = "AppEnlight :: ALERT %s: %s has uptime issues" % (
+            template_vars["alert_action"],
+            template_vars["resource_name"],
         )
-        template_vars['email_title'] = title
+        template_vars["email_title"] = title
 
-        UserService.send_email(kwargs['request'], [self.channel_value],
+        UserService.send_email(
+            kwargs["request"],
+            [self.channel_value],
                                template_vars,
-                               '/email_templates/alert_uptime.jinja2')
+            "/email_templates/alert_uptime.jinja2",
+        )
 
     def notify_chart_alert(self, **kwargs):
         """
@@ -163,13 +175,18 b' class EmailAlertChannel(AlertChannel):'
         """
         template_vars = self.chart_alert_notification_vars(kwargs)
 
-        title = 'AppEnlight :: ALERT {} value in "{}" chart' \
+        title = (
+            'AppEnlight :: ALERT {} value in "{}" chart'
                 ' met alert "{}" criteria'.format(
-            template_vars['alert_action'],
-            template_vars['chart_name'],
-            template_vars['action_name'],
+                template_vars["alert_action"],
+                template_vars["chart_name"],
+                template_vars["action_name"],
         )
-        template_vars['email_title'] = title
-        UserService.send_email(kwargs['request'], [self.channel_value],
+        )
+        template_vars["email_title"] = title
+        UserService.send_email(
+            kwargs["request"],
+            [self.channel_value],
                                template_vars,
-                               '/email_templates/alert_chart.jinja2')
+            "/email_templates/alert_chart.jinja2",
+        )

backend/src/appenlight/models/alert_channels/flowdock.py

@@ -23,9 +23,7 b' log = logging.getLogger(__name__)'
 
 
 class FlowdockAlertChannel(AlertChannel):
-    __mapper_args__ = {
-        'polymorphic_identity': 'flowdock'
-    }
+    __mapper_args__ = {"polymorphic_identity": "flowdock"}
 
     def notify_reports(self, **kwargs):
         """
@@ -41,44 +39,45 b' class FlowdockAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        app_url = kwargs['request'].registry.settings['_mail_url']
-        destination_url = kwargs['request'].route_url('/',
-                                                      _app_url=app_url)
-        f_args = ('report',
-                  template_vars['resource'].resource_id,
-                  template_vars['url_start_date'].strftime('%Y-%m-%dT%H:%M'),
-                  template_vars['url_end_date'].strftime('%Y-%m-%dT%H:%M'))
-        destination_url += 'ui/{}?resource={}&start_date={}&end_date={}'.format(
-            *f_args)
-
-        if template_vars['confirmed_total'] > 1:
+        app_url = kwargs["request"].registry.settings["_mail_url"]
+        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
+        f_args = (
+            "report",
+            template_vars["resource"].resource_id,
+            template_vars["url_start_date"].strftime("%Y-%m-%dT%H:%M"),
+            template_vars["url_end_date"].strftime("%Y-%m-%dT%H:%M"),
+        )
+        destination_url += "ui/{}?resource={}&start_date={}&end_date={}".format(*f_args)
+
+        if template_vars["confirmed_total"] > 1:
             template_vars["title"] = "%s - %s reports" % (
-                template_vars['resource_name'],
-                template_vars['confirmed_total'],
+                template_vars["resource_name"],
+                template_vars["confirmed_total"],
             )
         else:
-            error_title = truncate(template_vars['reports'][0][1].error or
-                                   'slow report', 90)
+            error_title = truncate(
+                template_vars["reports"][0][1].error or "slow report", 90
+            )
             template_vars["title"] = "%s - '%s' report" % (
-                template_vars['resource_name'],
-                error_title)
+                template_vars["resource_name"],
+                error_title,
+            )
 
-        log_msg = 'NOTIFY : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "NOTIFY : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
-        client = FlowdockIntegration.create_client(
-            self.integration.config['api_token'])
+        client = FlowdockIntegration.create_client(self.integration.config["api_token"])
         payload = {
             "source": "AppEnlight",
-            "from_address": kwargs['request'].registry.settings[
-                'mailing.from_email'],
+            "from_address": kwargs["request"].registry.settings["mailing.from_email"],
             "subject": template_vars["title"],
             "content": "New report present",
             "tags": ["appenlight"],
-            "link": destination_url
+            "link": destination_url,
         }
         client.send_to_inbox(payload)
 
@@ -95,32 +94,30 b' class FlowdockAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if kwargs['event'].unified_alert_action() == 'OPEN':
+        if kwargs["event"].unified_alert_action() == "OPEN":
 
-            title = 'ALERT %s: %s - %s %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                kwargs['event'].values['reports'],
-                template_vars['report_type'],
+            title = "ALERT %s: %s - %s %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                kwargs["event"].values["reports"],
+                template_vars["report_type"],
             )
 
         else:
-            title = 'ALERT %s: %s type: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                template_vars['alert_type'].replace('_', ' '),
+            title = "ALERT %s: %s type: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                template_vars["alert_type"].replace("_", " "),
             )
 
-        client = FlowdockIntegration.create_client(
-            self.integration.config['api_token'])
+        client = FlowdockIntegration.create_client(self.integration.config["api_token"])
         payload = {
             "source": "AppEnlight",
-            "from_address": kwargs['request'].registry.settings[
-                'mailing.from_email'],
+            "from_address": kwargs["request"].registry.settings["mailing.from_email"],
             "subject": title,
-            "content": 'Investigation required',
-            "tags": ["appenlight", "alert", template_vars['alert_type']],
-            "link": template_vars['destination_url']
+            "content": "Investigation required",
+            "tags": ["appenlight", "alert", template_vars["alert_type"]],
+            "link": template_vars["destination_url"],
         }
         client.send_to_inbox(payload)
 
@@ -137,23 +134,21 b' class FlowdockAlertChannel(AlertChannel):'
         """
         template_vars = self.uptime_alert_notification_vars(kwargs)
 
-        message = 'ALERT %s: %s has uptime issues' % (
-            template_vars['alert_action'],
-            template_vars['resource_name'],
+        message = "ALERT %s: %s has uptime issues" % (
+            template_vars["alert_action"],
+            template_vars["resource_name"],
         )
-        submessage = 'Info: '
-        submessage += template_vars['reason']
+        submessage = "Info: "
+        submessage += template_vars["reason"]
 
-        client = FlowdockIntegration.create_client(
-            self.integration.config['api_token'])
+        client = FlowdockIntegration.create_client(self.integration.config["api_token"])
         payload = {
             "source": "AppEnlight",
-            "from_address": kwargs['request'].registry.settings[
-                'mailing.from_email'],
+            "from_address": kwargs["request"].registry.settings["mailing.from_email"],
             "subject": message,
             "content": submessage,
-            "tags": ["appenlight", "alert", 'uptime'],
-            "link": template_vars['destination_url']
+            "tags": ["appenlight", "alert", "uptime"],
+            "link": template_vars["destination_url"],
         }
         client.send_to_inbox(payload)
 
@@ -171,29 +166,29 b' class FlowdockAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
         message = "Daily report digest: %s - %s reports" % (
-            template_vars['resource_name'], template_vars['confirmed_total'])
+            template_vars["resource_name"],
+            template_vars["confirmed_total"],
+        )
 
-        f_args = (template_vars['confirmed_total'],
-                  template_vars['timestamp'])
+        f_args = (template_vars["confirmed_total"], template_vars["timestamp"])
 
         payload = {
             "source": "AppEnlight",
-            "from_address": kwargs['request'].registry.settings[
-                'mailing.from_email'],
+            "from_address": kwargs["request"].registry.settings["mailing.from_email"],
             "subject": message,
-            "content": '%s reports in total since %s' % f_args,
+            "content": "%s reports in total since %s" % f_args,
             "tags": ["appenlight", "digest"],
-            "link": template_vars['destination_url']
+            "link": template_vars["destination_url"],
         }
 
-        client = FlowdockIntegration.create_client(
-            self.integration.config['api_token'])
+        client = FlowdockIntegration.create_client(self.integration.config["api_token"])
         client.send_to_inbox(payload)
 
-        log_msg = 'DIGEST  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "DIGEST  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
     def notify_chart_alert(self, **kwargs):
@@ -209,25 +204,22 b' class FlowdockAlertChannel(AlertChannel):'
         """
         template_vars = self.chart_alert_notification_vars(kwargs)
 
-        message = 'ALERT {}: value in "{}" chart ' \
-                  'met alert "{}" criteria'.format(
-            template_vars['alert_action'],
-            template_vars['chart_name'],
-            template_vars['action_name'],
+        message = 'ALERT {}: value in "{}" chart ' 'met alert "{}" criteria'.format(
+            template_vars["alert_action"],
+            template_vars["chart_name"],
+            template_vars["action_name"],
         )
-        submessage = 'Info: '
-        for item in template_vars['readable_values']:
-            submessage += '{}: {}\n'.format(item['label'], item['value'])
+        submessage = "Info: "
+        for item in template_vars["readable_values"]:
+            submessage += "{}: {}\n".format(item["label"], item["value"])
 
-        client = FlowdockIntegration.create_client(
-            self.integration.config['api_token'])
+        client = FlowdockIntegration.create_client(self.integration.config["api_token"])
         payload = {
             "source": "AppEnlight",
-            "from_address": kwargs['request'].registry.settings[
-                'mailing.from_email'],
+            "from_address": kwargs["request"].registry.settings["mailing.from_email"],
             "subject": message,
             "content": submessage,
-            "tags": ["appenlight", "alert", 'chart'],
-            "link": template_vars['destination_url']
+            "tags": ["appenlight", "alert", "chart"],
+            "link": template_vars["destination_url"],
         }
         client.send_to_inbox(payload)

backend/src/appenlight/models/alert_channels/hipchat.py

@@ -23,9 +23,7 b' log = logging.getLogger(__name__)'
 
 
 class HipchatAlertChannel(AlertChannel):
-    __mapper_args__ = {
-        'polymorphic_identity': 'hipchat'
-    }
+    __mapper_args__ = {"polymorphic_identity": "hipchat"}
 
     def notify_reports(self, **kwargs):
         """
@@ -41,46 +39,50 b' class HipchatAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        app_url = kwargs['request'].registry.settings['_mail_url']
-        destination_url = kwargs['request'].route_url('/',
-                                                      _app_url=app_url)
-        f_args = ('report',
-                  template_vars['resource'].resource_id,
-                  template_vars['url_start_date'].strftime('%Y-%m-%dT%H:%M'),
-                  template_vars['url_end_date'].strftime('%Y-%m-%dT%H:%M'))
-        destination_url += 'ui/{}?resource={}&start_date={}&end_date={}'.format(
-            *f_args)
-
-        if template_vars['confirmed_total'] > 1:
+        app_url = kwargs["request"].registry.settings["_mail_url"]
+        destination_url = kwargs["request"].route_url("/", _app_url=app_url)
+        f_args = (
+            "report",
+            template_vars["resource"].resource_id,
+            template_vars["url_start_date"].strftime("%Y-%m-%dT%H:%M"),
+            template_vars["url_end_date"].strftime("%Y-%m-%dT%H:%M"),
+        )
+        destination_url += "ui/{}?resource={}&start_date={}&end_date={}".format(*f_args)
+
+        if template_vars["confirmed_total"] > 1:
             template_vars["title"] = "%s - %s reports" % (
-                template_vars['resource_name'],
-                template_vars['confirmed_total'],
+                template_vars["resource_name"],
+                template_vars["confirmed_total"],
             )
         else:
-            error_title = truncate(template_vars['reports'][0][1].error or
-                                   'slow report', 90)
+            error_title = truncate(
+                template_vars["reports"][0][1].error or "slow report", 90
+            )
             template_vars["title"] = "%s - '%s' report" % (
-                template_vars['resource_name'],
-                error_title)
+                template_vars["resource_name"],
+                error_title,
+            )
 
-        template_vars["title"] += ' ' + destination_url
+        template_vars["title"] += " " + destination_url
 
-        log_msg = 'NOTIFY  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "NOTIFY  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
-        client = HipchatIntegration.create_client(
-            self.integration.config['api_token'])
-        for room in self.integration.config['rooms'].split(','):
-            client.send({
-                "message_format": 'text',
+        client = HipchatIntegration.create_client(self.integration.config["api_token"])
+        for room in self.integration.config["rooms"].split(","):
+            client.send(
+                {
+                    "message_format": "text",
                 "message": template_vars["title"],
                 "from": "AppEnlight",
                 "room_id": room.strip(),
-                "color": "yellow"
-            })
+                    "color": "yellow",
+                }
+            )
 
     def notify_report_alert(self, **kwargs):
         """
@@ -95,35 +97,37 b' class HipchatAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if kwargs['event'].unified_alert_action() == 'OPEN':
+        if kwargs["event"].unified_alert_action() == "OPEN":
 
-            title = 'ALERT %s: %s - %s %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                kwargs['event'].values['reports'],
-                template_vars['report_type'],
+            title = "ALERT %s: %s - %s %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                kwargs["event"].values["reports"],
+                template_vars["report_type"],
             )
 
         else:
-            title = 'ALERT %s: %s type: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
-                template_vars['alert_type'].replace('_', ' '),
+            title = "ALERT %s: %s type: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
+                template_vars["alert_type"].replace("_", " "),
             )
 
-        title += '\n ' + template_vars['destination_url']
+        title += "\n " + template_vars["destination_url"]
 
-        api_token = self.integration.config['api_token']
+        api_token = self.integration.config["api_token"]
         client = HipchatIntegration.create_client(api_token)
-        for room in self.integration.config['rooms'].split(','):
-            client.send({
-                "message_format": 'text',
+        for room in self.integration.config["rooms"].split(","):
+            client.send(
+                {
+                    "message_format": "text",
                 "message": title,
                 "from": "AppEnlight",
                 "room_id": room.strip(),
                 "color": "red",
-                "notify": '1'
-            })
+                    "notify": "1",
+                }
+            )
 
     def notify_uptime_alert(self, **kwargs):
         """
@@ -138,24 +142,26 b' class HipchatAlertChannel(AlertChannel):'
         """
         template_vars = self.uptime_alert_notification_vars(kwargs)
 
-        message = 'ALERT %s: %s has uptime issues\n' % (
-            template_vars['alert_action'],
-            template_vars['resource_name'],
+        message = "ALERT %s: %s has uptime issues\n" % (
+            template_vars["alert_action"],
+            template_vars["resource_name"],
         )
-        message += template_vars['reason']
-        message += '\n{}'.format(template_vars['destination_url'])
+        message += template_vars["reason"]
+        message += "\n{}".format(template_vars["destination_url"])
 
-        api_token = self.integration.config['api_token']
+        api_token = self.integration.config["api_token"]
         client = HipchatIntegration.create_client(api_token)
-        for room in self.integration.config['rooms'].split(','):
-            client.send({
-                "message_format": 'text',
+        for room in self.integration.config["rooms"].split(","):
+            client.send(
+                {
+                    "message_format": "text",
                 "message": message,
                 "from": "AppEnlight",
                 "room_id": room.strip(),
                 "color": "red",
-                "notify": '1'
-            })
+                    "notify": "1",
+                }
+            )
 
     def notify_chart_alert(self, **kwargs):
         """
@@ -169,29 +175,30 b' class HipchatAlertChannel(AlertChannel):'
 
         """
         template_vars = self.chart_alert_notification_vars(kwargs)
-        message = 'ALERT {}: value in "{}" chart: ' \
-                  'met alert "{}" criteria\n'.format(
-            template_vars['alert_action'],
-            template_vars['chart_name'],
-            template_vars['action_name'],
+        message = 'ALERT {}: value in "{}" chart: ' 'met alert "{}" criteria\n'.format(
+            template_vars["alert_action"],
+            template_vars["chart_name"],
+            template_vars["action_name"],
         )
 
-        for item in template_vars['readable_values']:
-            message += '{}: {}\n'.format(item['label'], item['value'])
+        for item in template_vars["readable_values"]:
+            message += "{}: {}\n".format(item["label"], item["value"])
 
-        message += template_vars['destination_url']
+        message += template_vars["destination_url"]
 
-        api_token = self.integration.config['api_token']
+        api_token = self.integration.config["api_token"]
         client = HipchatIntegration.create_client(api_token)
-        for room in self.integration.config['rooms'].split(','):
-            client.send({
-                "message_format": 'text',
+        for room in self.integration.config["rooms"].split(","):
+            client.send(
+                {
+                    "message_format": "text",
                 "message": message,
                 "from": "AppEnlight",
                 "room_id": room.strip(),
                 "color": "red",
-                "notify": '1'
-            })
+                    "notify": "1",
+                }
+            )
 
     def send_digest(self, **kwargs):
         """
@@ -206,24 +213,26 b' class HipchatAlertChannel(AlertChannel):'
 
         """
         template_vars = self.report_alert_notification_vars(kwargs)
-        f_args = (template_vars['resource_name'],
-                  template_vars['confirmed_total'],)
+        f_args = (template_vars["resource_name"], template_vars["confirmed_total"])
         message = "Daily report digest: %s - %s reports" % f_args
-        message += '\n{}'.format(template_vars['destination_url'])
-        api_token = self.integration.config['api_token']
+        message += "\n{}".format(template_vars["destination_url"])
+        api_token = self.integration.config["api_token"]
         client = HipchatIntegration.create_client(api_token)
-        for room in self.integration.config['rooms'].split(','):
-            client.send({
-                "message_format": 'text',
+        for room in self.integration.config["rooms"].split(","):
+            client.send(
+                {
+                    "message_format": "text",
                 "message": message,
                 "from": "AppEnlight",
                 "room_id": room.strip(),
                 "color": "green",
-                "notify": '1'
-            })
+                    "notify": "1",
+                }
+            )
 
-        log_msg = 'DIGEST  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "DIGEST  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)

backend/src/appenlight/models/alert_channels/slack.py

@@ -23,9 +23,7 b' log = logging.getLogger(__name__)'
 
 
 class SlackAlertChannel(AlertChannel):
-    __mapper_args__ = {
-        'polymorphic_identity': 'slack'
-    }
+    __mapper_args__ = {"polymorphic_identity": "slack"}
 
     def notify_reports(self, **kwargs):
         """
@@ -40,45 +38,40 b' class SlackAlertChannel(AlertChannel):'
 
         """
         template_vars = self.report_alert_notification_vars(kwargs)
-        template_vars["title"] = template_vars['resource_name']
+        template_vars["title"] = template_vars["resource_name"]
 
-        if template_vars['confirmed_total'] > 1:
-            template_vars['subtext'] = '%s reports' % template_vars[
-                'confirmed_total']
+        if template_vars["confirmed_total"] > 1:
+            template_vars["subtext"] = "%s reports" % template_vars["confirmed_total"]
         else:
-            error_title = truncate(template_vars['reports'][0][1].error or
-                                   'slow report', 90)
-            template_vars['subtext'] = error_title
+            error_title = truncate(
+                template_vars["reports"][0][1].error or "slow report", 90
+            )
+            template_vars["subtext"] = error_title
 
-        log_msg = 'NOTIFY  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "NOTIFY  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)
 
-        client = SlackIntegration.create_client(
-            self.integration.config['webhook_url'])
+        client = SlackIntegration.create_client(self.integration.config["webhook_url"])
         report_data = {
             "username": "AppEnlight",
             "icon_emoji": ":fire:",
             "attachments": [
                 {
                     "mrkdwn_in": ["text", "pretext", "title", "fallback"],
-                    "fallback": "*%s* - <%s| Browse>" % (
-                        template_vars["title"],
-                        template_vars['destination_url']),
-                    "pretext": "*%s* - <%s| Browse>" % (
-                        template_vars["title"],
-                        template_vars['destination_url']),
+                    "fallback": "*%s* - <%s| Browse>"
+                    % (template_vars["title"], template_vars["destination_url"]),
+                    "pretext": "*%s* - <%s| Browse>"
+                    % (template_vars["title"], template_vars["destination_url"]),
                     "color": "warning",
                     "fields": [
-                        {
-                            "value": 'Info: %s' % template_vars['subtext'],
-                            "short": False
+                        {"value": "Info: %s" % template_vars["subtext"], "short": False}
+                    ],
                         }
-                    ]
-                }
-            ]
+            ],
         }
         client.make_request(data=report_data)
 
@@ -95,53 +88,51 b' class SlackAlertChannel(AlertChannel):'
         """
         template_vars = self.report_alert_notification_vars(kwargs)
 
-        if kwargs['event'].unified_alert_action() == 'OPEN':
-            title = '*ALERT %s*: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name']
+        if kwargs["event"].unified_alert_action() == "OPEN":
+            title = "*ALERT %s*: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
             )
 
-            template_vars['subtext'] = 'Got at least %s %s' % (
-                kwargs['event'].values['reports'],
-                template_vars['report_type']
+            template_vars["subtext"] = "Got at least %s %s" % (
+                kwargs["event"].values["reports"],
+                template_vars["report_type"],
             )
 
         else:
-            title = '*ALERT %s*: %s' % (
-                template_vars['alert_action'],
-                template_vars['resource_name'],
+            title = "*ALERT %s*: %s" % (
+                template_vars["alert_action"],
+                template_vars["resource_name"],
             )
 
-            template_vars['subtext'] = ''
+            template_vars["subtext"] = ""
 
-        alert_type = template_vars['alert_type'].replace('_', ' ')
-        alert_type = alert_type.replace('alert', '').capitalize()
+        alert_type = template_vars["alert_type"].replace("_", " ")
+        alert_type = alert_type.replace("alert", "").capitalize()
 
-        template_vars['type'] = "Type: %s" % alert_type
+        template_vars["type"] = "Type: %s" % alert_type
 
-        client = SlackIntegration.create_client(
-            self.integration.config['webhook_url']
-        )
+        client = SlackIntegration.create_client(self.integration.config["webhook_url"])
         report_data = {
             "username": "AppEnlight",
             "icon_emoji": ":rage:",
             "attachments": [
                 {
                     "mrkdwn_in": ["text", "pretext", "title", "fallback"],
-                    "fallback": "%s - <%s| Browse>" % (
-                        title, template_vars['destination_url']),
-                    "pretext": "%s - <%s| Browse>" % (
-                        title, template_vars['destination_url']),
+                    "fallback": "%s - <%s| Browse>"
+                    % (title, template_vars["destination_url"]),
+                    "pretext": "%s - <%s| Browse>"
+                    % (title, template_vars["destination_url"]),
                     "color": "danger",
                     "fields": [
                         {
-                            "title": template_vars['type'],
-                            "value": template_vars['subtext'],
-                            "short": False
+                            "title": template_vars["type"],
+                            "value": template_vars["subtext"],
+                            "short": False,
                         }
-                    ]
+                    ],
                 }
-            ]
+            ],
         }
         client.make_request(data=report_data)
 
@@ -158,13 +149,11 b' class SlackAlertChannel(AlertChannel):'
         """
         template_vars = self.uptime_alert_notification_vars(kwargs)
 
-        title = '*ALERT %s*: %s' % (
-            template_vars['alert_action'],
-            template_vars['resource_name'],
-        )
-        client = SlackIntegration.create_client(
-            self.integration.config['webhook_url']
+        title = "*ALERT %s*: %s" % (
+            template_vars["alert_action"],
+            template_vars["resource_name"],
         )
+        client = SlackIntegration.create_client(self.integration.config["webhook_url"])
         report_data = {
             "username": "AppEnlight",
             "icon_emoji": ":rage:",
@@ -172,19 +161,21 b' class SlackAlertChannel(AlertChannel):'
                 {
                     "mrkdwn_in": ["text", "pretext", "title", "fallback"],
                     "fallback": "{} - <{}| Browse>".format(
-                        title, template_vars['destination_url']),
+                        title, template_vars["destination_url"]
+                    ),
                     "pretext": "{} - <{}| Browse>".format(
-                        title, template_vars['destination_url']),
+                        title, template_vars["destination_url"]
+                    ),
                     "color": "danger",
                     "fields": [
                         {
                             "title": "Application has uptime issues",
-                            "value": template_vars['reason'],
-                            "short": False
+                            "value": template_vars["reason"],
+                            "short": False,
                         }
-                    ]
+                    ],
                 }
-            ]
+            ],
         }
         client.make_request(data=report_data)
 
@@ -201,39 +192,39 b' class SlackAlertChannel(AlertChannel):'
         """
         template_vars = self.chart_alert_notification_vars(kwargs)
 
-        title = '*ALERT {}*: value in *"{}"* chart ' \
-                'met alert *"{}"* criteria'.format(
-            template_vars['alert_action'],
-            template_vars['chart_name'],
-            template_vars['action_name'],
+        title = '*ALERT {}*: value in *"{}"* chart ' 'met alert *"{}"* criteria'.format(
+            template_vars["alert_action"],
+            template_vars["chart_name"],
+            template_vars["action_name"],
         )
 
-        subtext = ''
-        for item in template_vars['readable_values']:
-            subtext += '{} - {}\n'.format(item['label'], item['value'])
+        subtext = ""
+        for item in template_vars["readable_values"]:
+            subtext += "{} - {}\n".format(item["label"], item["value"])
 
-        client = SlackIntegration.create_client(
-            self.integration.config['webhook_url']
-        )
+        client = SlackIntegration.create_client(self.integration.config["webhook_url"])
         report_data = {
             "username": "AppEnlight",
             "icon_emoji": ":rage:",
             "attachments": [
-                {"mrkdwn_in": ["text", "pretext", "title", "fallback"],
+                {
+                    "mrkdwn_in": ["text", "pretext", "title", "fallback"],
                  "fallback": "{} - <{}| Browse>".format(
-                     title, template_vars['destination_url']),
+                        title, template_vars["destination_url"]
+                    ),
                  "pretext": "{} - <{}| Browse>".format(
-                     title, template_vars['destination_url']),
+                        title, template_vars["destination_url"]
+                    ),
                  "color": "danger",
                  "fields": [
                      {
                          "title": "Following criteria were met:",
                          "value": subtext,
-                         "short": False
+                            "short": False,
                      }
-                 ]
+                    ],
                  }
-            ]
+            ],
         }
         client.make_request(data=report_data)
 
@@ -250,36 +241,30 b' class SlackAlertChannel(AlertChannel):'
 
         """
         template_vars = self.report_alert_notification_vars(kwargs)
-        title = "*Daily report digest*: %s" % template_vars['resource_name']
+        title = "*Daily report digest*: %s" % template_vars["resource_name"]
 
-        subtext = '%s reports' % template_vars['confirmed_total']
+        subtext = "%s reports" % template_vars["confirmed_total"]
 
-        client = SlackIntegration.create_client(
-            self.integration.config['webhook_url']
-        )
+        client = SlackIntegration.create_client(self.integration.config["webhook_url"])
         report_data = {
             "username": "AppEnlight",
             "attachments": [
                 {
                     "mrkdwn_in": ["text", "pretext", "title", "fallback"],
-                    "fallback": "%s : <%s| Browse>" % (
-                        title, template_vars['destination_url']),
-                    "pretext": "%s: <%s| Browse>" % (
-                        title, template_vars['destination_url']),
+                    "fallback": "%s : <%s| Browse>"
+                    % (title, template_vars["destination_url"]),
+                    "pretext": "%s: <%s| Browse>"
+                    % (title, template_vars["destination_url"]),
                     "color": "good",
-                    "fields": [
-                        {
-                            "title": "Got at least: %s" % subtext,
-                            "short": False
-                        }
-                    ]
+                    "fields": [{"title": "Got at least: %s" % subtext, "short": False}],
                 }
-            ]
+            ],
         }
         client.make_request(data=report_data)
 
-        log_msg = 'DIGEST  : %s via %s :: %s reports' % (
-            kwargs['user'].user_name,
+        log_msg = "DIGEST  : %s via %s :: %s reports" % (
+            kwargs["user"].user_name,
             self.channel_visible_value,
-            template_vars['confirmed_total'])
+            template_vars["confirmed_total"],
+        )
         log.warning(log_msg)

backend/src/appenlight/models/application.py

@@ -24,7 +24,7 b' log = logging.getLogger(__name__)'
 
 
 def generate_api_key():
-    uid = str(uuid.uuid4()).replace('-', '')
+    uid = str(uuid.uuid4()).replace("-", "")
     return uid[0:32]
 
 
@@ -33,61 +33,69 b' class Application(Resource):'
     Resource of application type
     """
 
-    __tablename__ = 'applications'
-    __mapper_args__ = {'polymorphic_identity': 'application'}
+    __tablename__ = "applications"
+    __mapper_args__ = {"polymorphic_identity": "application"}
 
     # lists configurable possible permissions for this resource type
-    __possible_permissions__ = ('view', 'update_reports')
-
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('resources.resource_id',
-                                          onupdate='CASCADE',
-                                          ondelete='CASCADE', ),
-                            primary_key=True, )
-    domains = sa.Column(sa.UnicodeText(), nullable=False, default='')
-    api_key = sa.Column(sa.String(32), nullable=False, unique=True, index=True,
-                        default=generate_api_key)
-    public_key = sa.Column(sa.String(32), nullable=False, unique=True,
-                           index=True,
-                           default=generate_api_key)
-    default_grouping = sa.Column(sa.Unicode(20), nullable=False,
-                                 default='url_traceback')
+    __possible_permissions__ = ("view", "update_reports")
+
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey("resources.resource_id", onupdate="CASCADE", ondelete="CASCADE"),
+        primary_key=True,
+    )
+    domains = sa.Column(sa.UnicodeText(), nullable=False, default="")
+    api_key = sa.Column(
+        sa.String(32), nullable=False, unique=True, index=True, default=generate_api_key
+    )
+    public_key = sa.Column(
+        sa.String(32), nullable=False, unique=True, index=True, default=generate_api_key
+    )
+    default_grouping = sa.Column(
+        sa.Unicode(20), nullable=False, default="url_traceback"
+    )
     error_report_threshold = sa.Column(sa.Integer(), default=10)
     slow_report_threshold = sa.Column(sa.Integer(), default=10)
-    allow_permanent_storage = sa.Column(sa.Boolean(), default=False,
-                                        nullable=False)
+    allow_permanent_storage = sa.Column(sa.Boolean(), default=False, nullable=False)
 
-    @sa.orm.validates('default_grouping')
+    @sa.orm.validates("default_grouping")
     def validate_default_grouping(self, key, grouping):
         """ validate if resouce can have specific permission """
-        assert grouping in ['url_type', 'url_traceback', 'traceback_server']
+        assert grouping in ["url_type", "url_traceback", "traceback_server"]
         return grouping
 
-    report_groups = sa.orm.relationship('ReportGroup',
+    report_groups = sa.orm.relationship(
+        "ReportGroup",
                                         cascade="all, delete-orphan",
                                         passive_deletes=True,
                                         passive_updates=True,
-                                        lazy='dynamic',
-                                        backref=sa.orm.backref('application',
-                                                               lazy="joined"))
+        lazy="dynamic",
+        backref=sa.orm.backref("application", lazy="joined"),
+    )
 
-    postprocess_conf = sa.orm.relationship('ApplicationPostprocessConf',
+    postprocess_conf = sa.orm.relationship(
+        "ApplicationPostprocessConf",
                                            cascade="all, delete-orphan",
                                            passive_deletes=True,
                                            passive_updates=True,
-                                           backref='resource')
+        backref="resource",
+    )
 
-    logs = sa.orm.relationship('Log',
-                               lazy='dynamic',
-                               backref='application',
+    logs = sa.orm.relationship(
+        "Log",
+        lazy="dynamic",
+        backref="application",
                                passive_deletes=True,
-                               passive_updates=True, )
+        passive_updates=True,
+    )
 
-    integrations = sa.orm.relationship('IntegrationBase',
-                                       backref='resource',
+    integrations = sa.orm.relationship(
+        "IntegrationBase",
+        backref="resource",
                                        cascade="all, delete-orphan",
                                        passive_deletes=True,
-                                       passive_updates=True, )
+        passive_updates=True,
+    )
 
     def generate_api_key(self):
         return generate_api_key()
@@ -95,10 +103,11 b' class Application(Resource):'
 
 def after_update(mapper, connection, target):
     from appenlight.models.services.application import ApplicationService
-    log.info('clearing out ApplicationService cache')
+
+    log.info("clearing out ApplicationService cache")
     ApplicationService.by_id_cached().invalidate(target.resource_id)
     ApplicationService.by_api_key_cached().invalidate(target.api_key)
 
 
-sa.event.listen(Application, 'after_update', after_update)
-sa.event.listen(Application, 'after_delete', after_update)
+sa.event.listen(Application, "after_update", after_update)
+sa.event.listen(Application, "after_delete", after_update)

backend/src/appenlight/models/application_postprocess_conf.py

@@ -27,18 +27,20 b' class ApplicationPostprocessConf(Base, BaseModel):'
     This is later used for rule parsing like "if 10 occurences bump priority +1"
     """
 
-    __tablename__ = 'application_postprocess_conf'
+    __tablename__ = "application_postprocess_conf"
 
     pkey = sa.Column(sa.Integer(), nullable=False, primary_key=True)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('resources.resource_id',
-                                          onupdate='CASCADE',
-                                          ondelete='CASCADE'))
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey("resources.resource_id", onupdate="CASCADE", ondelete="CASCADE"),
+    )
     do = sa.Column(sa.Unicode(25), nullable=False)
-    new_value = sa.Column(sa.UnicodeText(), nullable=False, default='')
-    rule = sa.Column(sa.dialects.postgresql.JSON,
-                     nullable=False, default={'field': 'http_status',
-                                              "op": "ge", "value": "500"})
+    new_value = sa.Column(sa.UnicodeText(), nullable=False, default="")
+    rule = sa.Column(
+        sa.dialects.postgresql.JSON,
+        nullable=False,
+        default={"field": "http_status", "op": "ge", "value": "500"},
+    )
 
     def postprocess(self, item):
         new_value = int(self.new_value)

backend/src/appenlight/models/auth_token.py

@@ -29,17 +29,22 b' class AuthToken(Base, BaseModel):'
     """
     Stores information about possible alerting options
     """
-    __tablename__ = 'auth_tokens'
+
+    __tablename__ = "auth_tokens"
 
     id = sa.Column(sa.Integer, primary_key=True, nullable=False)
-    token = sa.Column(sa.Unicode(40), nullable=False,
-                      default=lambda x: UserService.generate_random_string(40))
-    owner_id = sa.Column(sa.Unicode(30),
-                         sa.ForeignKey('users.id', onupdate='CASCADE',
-                                       ondelete='CASCADE'))
+    token = sa.Column(
+        sa.Unicode(40),
+        nullable=False,
+        default=lambda x: UserService.generate_random_string(40),
+    )
+    owner_id = sa.Column(
+        sa.Unicode(30),
+        sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE"),
+    )
     creation_date = sa.Column(sa.DateTime, default=lambda x: datetime.utcnow())
     expires = sa.Column(sa.DateTime)
-    description = sa.Column(sa.Unicode, default='')
+    description = sa.Column(sa.Unicode, default="")
 
     @property
     def is_expired(self):
@@ -49,4 +54,4 b' class AuthToken(Base, BaseModel):'
             return False
 
     def __str__(self):
-        return '<AuthToken u:%s t:%s...>' % (self.owner_id, self.token[0:10])
+        return "<AuthToken u:%s t:%s...>" % (self.owner_id, self.token[0:10])

backend/src/appenlight/models/config.py

@@ -22,7 +22,7 b' from . import Base'
 
 
 class Config(Base, BaseModel):
-    __tablename__ = 'config'
+    __tablename__ = "config"
 
     key = sa.Column(sa.Unicode, primary_key=True)
     section = sa.Column(sa.Unicode, primary_key=True)

backend/src/appenlight/models/event.py

@@ -30,39 +30,40 b' log = logging.getLogger(__name__)'
 
 
 class Event(Base, BaseModel):
-    __tablename__ = 'events'
+    __tablename__ = "events"
 
-    types = {'error_report_alert': 1,
-             'slow_report_alert': 3,
-             'comment': 5,
-             'assignment': 6,
-             'uptime_alert': 7,
-             'chart_alert': 9}
+    types = {
+        "error_report_alert": 1,
+        "slow_report_alert": 3,
+        "comment": 5,
+        "assignment": 6,
+        "uptime_alert": 7,
+        "chart_alert": 9,
+    }
 
-    statuses = {'active': 1,
-                'closed': 0}
+    statuses = {"active": 1, "closed": 0}
 
     id = sa.Column(sa.Integer, primary_key=True)
     start_date = sa.Column(sa.DateTime, default=datetime.utcnow)
     end_date = sa.Column(sa.DateTime)
     status = sa.Column(sa.Integer, default=1)
     event_type = sa.Column(sa.Integer, default=1)
-    origin_user_id = sa.Column(sa.Integer(), sa.ForeignKey('users.id'),
-                               nullable=True)
-    target_user_id = sa.Column(sa.Integer(), sa.ForeignKey('users.id'),
-                               nullable=True)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('resources.resource_id'),
-                            nullable=True)
+    origin_user_id = sa.Column(sa.Integer(), sa.ForeignKey("users.id"), nullable=True)
+    target_user_id = sa.Column(sa.Integer(), sa.ForeignKey("users.id"), nullable=True)
+    resource_id = sa.Column(
+        sa.Integer(), sa.ForeignKey("resources.resource_id"), nullable=True
+    )
     target_id = sa.Column(sa.Integer)
     target_uuid = sa.Column(sa.Unicode(40))
     text = sa.Column(sa.UnicodeText())
     values = sa.Column(JSON(), nullable=False, default=None)
 
     def __repr__(self):
-        return '<Event %s, app:%s, %s>' % (self.unified_alert_name(),
+        return "<Event %s, app:%s, %s>" % (
+            self.unified_alert_name(),
                                             self.resource_id,
-                                            self.unified_alert_action())
+            self.unified_alert_action(),
+        )
 
     @property
     def reverse_types(self):
@@ -73,9 +74,9 b' class Event(Base, BaseModel):'
 
     def unified_alert_action(self):
         event_name = self.reverse_types[self.event_type]
-        if self.status == Event.statuses['closed']:
+        if self.status == Event.statuses["closed"]:
             return "CLOSE"
-        if self.status != Event.statuses['closed']:
+        if self.status != Event.statuses["closed"]:
             return "OPEN"
         return event_name
 
@@ -89,30 +90,33 b' class Event(Base, BaseModel):'
             request = get_current_request()
         if not resource:
             return
-        users = set([p.user for p in ResourceService.users_for_perm(resource, 'view')])
+        users = set([p.user for p in ResourceService.users_for_perm(resource, "view")])
         for user in users:
             for channel in user.alert_channels:
-                matches_resource = not channel.resources or resource in [r.resource_id for r in channel.resources]
+                matches_resource = not channel.resources or resource in [
+                    r.resource_id for r in channel.resources
+                ]
                 if (
-                    not channel.channel_validated or
-                    not channel.send_alerts or
-                    not matches_resource
+                    not channel.channel_validated
+                    or not channel.send_alerts
+                    or not matches_resource
                 ):
                     continue
                 else:
                     try:
-                        channel.notify_alert(resource=resource,
-                                             event=self,
-                                             user=user,
-                                             request=request)
+                        channel.notify_alert(
+                            resource=resource, event=self, user=user, request=request
+                        )
                     except IntegrationException as e:
-                        log.warning('%s' % e)
+                        log.warning("%s" % e)
 
     def validate_or_close(self, since_when, db_session=None):
         """ Checks if alerts should stay open or it's time to close them.
             Generates close alert event if alerts get closed """
-        event_types = [Event.types['error_report_alert'],
-                       Event.types['slow_report_alert']]
+        event_types = [
+            Event.types["error_report_alert"],
+            Event.types["slow_report_alert"],
+        ]
         app = ResourceService.by_resource_id(self.resource_id)
         # if app was deleted close instantly
         if not app:
@@ -121,10 +125,11 b' class Event(Base, BaseModel):'
 
         if self.event_type in event_types:
             total = ReportStatService.count_by_type(
-                self.event_type, self.resource_id, since_when)
-            if Event.types['error_report_alert'] == self.event_type:
+                self.event_type, self.resource_id, since_when
+            )
+            if Event.types["error_report_alert"] == self.event_type:
                 threshold = app.error_report_threshold
-            if Event.types['slow_report_alert'] == self.event_type:
+            if Event.types["slow_report_alert"] == self.event_type:
                 threshold = app.slow_report_threshold
 
             if total < threshold:
@@ -135,31 +140,31 b' class Event(Base, BaseModel):'
         Closes an event and sends notification to affected users
         """
         self.end_date = datetime.utcnow()
-        self.status = Event.statuses['closed']
-        log.warning('ALERT: CLOSE: %s' % self)
+        self.status = Event.statuses["closed"]
+        log.warning("ALERT: CLOSE: %s" % self)
         self.send_alerts()
 
     def text_representation(self):
         alert_type = self.unified_alert_name()
-        text = ''
-        if 'slow_report' in alert_type:
-            text += 'Slow report alert'
-        if 'error_report' in alert_type:
-            text += 'Exception report alert'
-        if 'uptime_alert' in alert_type:
-            text += 'Uptime alert'
-        if 'chart_alert' in alert_type:
-            text += 'Metrics value alert'
+        text = ""
+        if "slow_report" in alert_type:
+            text += "Slow report alert"
+        if "error_report" in alert_type:
+            text += "Exception report alert"
+        if "uptime_alert" in alert_type:
+            text += "Uptime alert"
+        if "chart_alert" in alert_type:
+            text += "Metrics value alert"
 
         alert_action = self.unified_alert_action()
-        if alert_action == 'OPEN':
-            text += ' got opened.'
-        if alert_action == 'CLOSE':
-            text += ' got closed.'
+        if alert_action == "OPEN":
+            text += " got opened."
+        if alert_action == "CLOSE":
+            text += " got closed."
         return text
 
     def get_dict(self, request=None):
         dict_data = super(Event, self).get_dict()
-        dict_data['text'] = self.text_representation()
-        dict_data['resource_name'] = self.resource.resource_name
+        dict_data["text"] = self.text_representation()
+        dict_data["resource_name"] = self.resource.resource_name
         return dict_data

backend/src/appenlight/models/external_identity.py

@@ -25,12 +25,12 b' from appenlight.lib.sqlalchemy_fields import EncryptedUnicode'
 class ExternalIdentity(ExternalIdentityMixin, Base):
     @declared_attr
     def access_token(self):
-        return sa.Column(EncryptedUnicode(255), default='')
+        return sa.Column(EncryptedUnicode(255), default="")
 
     @declared_attr
     def alt_token(self):
-        return sa.Column(EncryptedUnicode(255), default='')
+        return sa.Column(EncryptedUnicode(255), default="")
 
     @declared_attr
     def token_secret(self):
-        return sa.Column(EncryptedUnicode(255), default='')
+        return sa.Column(EncryptedUnicode(255), default="")

backend/src/appenlight/models/group.py

@@ -19,27 +19,28 b' from appenlight.models import Base'
 
 
 class Group(GroupMixin, Base):
-    __possible_permissions__ = ('root_administration',
-                                'test_features',
-                                'admin_panel',
-                                'admin_users',
-                                'manage_partitions',)
+    __possible_permissions__ = (
+        "root_administration",
+        "test_features",
+        "admin_panel",
+        "admin_users",
+        "manage_partitions",
+    )
 
-    def get_dict(self, exclude_keys=None, include_keys=None,
-                 include_perms=False):
+    def get_dict(self, exclude_keys=None, include_keys=None, include_perms=False):
         result = super(Group, self).get_dict(exclude_keys, include_keys)
         if include_perms:
-            result['possible_permissions'] = self.__possible_permissions__
-            result['current_permissions'] = [p.perm_name for p in
-                                             self.permissions]
+            result["possible_permissions"] = self.__possible_permissions__
+            result["current_permissions"] = [p.perm_name for p in self.permissions]
         else:
-            result['possible_permissions'] = []
-            result['current_permissions'] = []
+            result["possible_permissions"] = []
+            result["current_permissions"] = []
         exclude_keys_list = exclude_keys or []
         include_keys_list = include_keys or []
         d = {}
         for k in result.keys():
-            if (k not in exclude_keys_list and
-                    (k in include_keys_list or not include_keys)):
+            if k not in exclude_keys_list and (
+                k in include_keys_list or not include_keys
+            ):
                 d[k] = result[k]
         return d

backend/src/appenlight/models/group_resource_permission.py

@@ -14,8 +14,9 b''
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ziggurat_foundations.models.group_resource_permission import \
-    GroupResourcePermissionMixin
+from ziggurat_foundations.models.group_resource_permission import (
+    GroupResourcePermissionMixin,
+)
 from appenlight.models import Base
 
 

backend/src/appenlight/models/integrations/__init__.py

@@ -32,34 +32,37 b' class IntegrationBase(Base, BaseModel):'
     """
     Model from which all integrations inherit using polymorphic approach
     """
-    __tablename__ = 'integrations'
+
+    __tablename__ = "integrations"
 
     front_visible = False
     as_alert_channel = False
     supports_report_alerting = False
 
     id = sa.Column(sa.Integer, primary_key=True)
-    resource_id = sa.Column(sa.Integer,
-                            sa.ForeignKey('applications.resource_id'))
+    resource_id = sa.Column(sa.Integer, sa.ForeignKey("applications.resource_id"))
     integration_name = sa.Column(sa.Unicode(64))
-    _config = sa.Column('config', JSON(), nullable=False, default='')
+    _config = sa.Column("config", JSON(), nullable=False, default="")
     modified_date = sa.Column(sa.DateTime)
 
-    channel = sa.orm.relationship('AlertChannel',
+    channel = sa.orm.relationship(
+        "AlertChannel",
                                   cascade="all,delete-orphan",
                                   passive_deletes=True,
                                   passive_updates=True,
                                   uselist=False,
-                                  backref='integration')
+        backref="integration",
+    )
 
     __mapper_args__ = {
-        'polymorphic_on': 'integration_name',
-        'polymorphic_identity': 'integration'
+        "polymorphic_on": "integration_name",
+        "polymorphic_identity": "integration",
     }
 
     @classmethod
-    def by_app_id_and_integration_name(cls, resource_id, integration_name,
-                                       db_session=None):
+    def by_app_id_and_integration_name(
+        cls, resource_id, integration_name, db_session=None
+    ):
         db_session = get_db_session(db_session)
         query = db_session.query(cls)
         query = query.filter(cls.integration_name == integration_name)
@@ -72,7 +75,6 b' class IntegrationBase(Base, BaseModel):'
 
     @config.setter
     def config(self, value):
-        if not hasattr(value, 'items'):
-            raise Exception('IntegrationBase.config only accepts '
-                            'flat dictionaries')
+        if not hasattr(value, "items"):
+            raise Exception("IntegrationBase.config only accepts " "flat dictionaries")
         self._config = encrypt_dictionary_keys(value)

backend/src/appenlight/models/integrations/bitbucket.py

@@ -16,8 +16,7 b''
 
 import requests
 from requests_oauthlib import OAuth1
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 
 _ = str
 
@@ -27,14 +26,12 b' class NotFoundException(Exception):'
 
 
 class BitbucketIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'bitbucket'
-    }
+    __mapper_args__ = {"polymorphic_identity": "bitbucket"}
     front_visible = True
     as_alert_channel = False
     supports_report_alerting = False
     action_notification = True
-    integration_action = 'Add issue to Bitbucket'
+    integration_action = "Add issue to Bitbucket"
 
     @classmethod
     def create_client(cls, request, user_name=None, repo_name=None):
@@ -46,27 +43,36 b' class BitbucketIntegration(IntegrationBase):'
         token = None
         secret = None
         for identity in request.user.external_identities:
-            if identity.provider_name == 'bitbucket':
+            if identity.provider_name == "bitbucket":
                 token = identity.access_token
                 secret = identity.token_secret
                 break
         if not token:
-            raise IntegrationException(
-                'No valid auth token present for this service')
-        client = BitbucketClient(token, secret,
+            raise IntegrationException("No valid auth token present for this service")
+        client = BitbucketClient(
+            token,
+            secret,
                                  user_name,
                                  repo_name,
-                                 config['authomatic.pr.bitbucket.key'],
-                                 config['authomatic.pr.bitbucket.secret'])
+            config["authomatic.pr.bitbucket.key"],
+            config["authomatic.pr.bitbucket.secret"],
+        )
         return client
 
 
 class BitbucketClient(object):
-    api_url = 'https://bitbucket.org/api/1.0'
-    repo_type = 'bitbucket'
-
-    def __init__(self, token, secret, owner, repo_name, bitbucket_consumer_key,
-                 bitbucket_consumer_secret):
+    api_url = "https://bitbucket.org/api/1.0"
+    repo_type = "bitbucket"
+
+    def __init__(
+        self,
+        token,
+        secret,
+        owner,
+        repo_name,
+        bitbucket_consumer_key,
+        bitbucket_consumer_secret,
+    ):
         self.access_token = token
         self.token_secret = secret
         self.owner = owner
@@ -75,89 +81,108 b' class BitbucketClient(object):'
         self.bitbucket_consumer_secret = bitbucket_consumer_secret
 
     possible_keys = {
-        'status': ['new', 'open', 'resolved', 'on hold', 'invalid',
-                   'duplicate', 'wontfix'],
-        'priority': ['trivial', 'minor', 'major', 'critical', 'blocker'],
-        'kind': ['bug', 'enhancement', 'proposal', 'task']
+        "status": [
+            "new",
+            "open",
+            "resolved",
+            "on hold",
+            "invalid",
+            "duplicate",
+            "wontfix",
+        ],
+        "priority": ["trivial", "minor", "major", "critical", "blocker"],
+        "kind": ["bug", "enhancement", "proposal", "task"],
     }
 
     def get_statuses(self):
         """Gets list of possible item statuses"""
-        return self.possible_keys['status']
+        return self.possible_keys["status"]
 
     def get_priorities(self):
         """Gets list of possible item statuses"""
-        return self.possible_keys['priority']
+        return self.possible_keys["priority"]
 
-    def make_request(self, url, method='get', data=None, headers=None):
+    def make_request(self, url, method="get", data=None, headers=None):
         """
         Performs HTTP request to bitbucket
         """
-        auth = OAuth1(self.bitbucket_consumer_key,
+        auth = OAuth1(
+            self.bitbucket_consumer_key,
                       self.bitbucket_consumer_secret,
-                      self.access_token, self.token_secret)
+            self.access_token,
+            self.token_secret,
+        )
         try:
-            resp = getattr(requests, method)(url, data=data, auth=auth,
-                                             timeout=10)
+            resp = getattr(requests, method)(url, data=data, auth=auth, timeout=10)
         except Exception as e:
             raise IntegrationException(
-                _('Error communicating with Bitbucket: %s') % (e,))
+                _("Error communicating with Bitbucket: %s") % (e,)
+            )
         if resp.status_code == 401:
-            raise IntegrationException(
-                _('You are not authorized to access this repo'))
+            raise IntegrationException(_("You are not authorized to access this repo"))
         elif resp.status_code == 404:
-            raise IntegrationException(_('User or repo name are incorrect'))
+            raise IntegrationException(_("User or repo name are incorrect"))
         elif resp.status_code not in [200, 201]:
             raise IntegrationException(
-                _('Bitbucket response_code: %s') % resp.status_code)
+                _("Bitbucket response_code: %s") % resp.status_code
+            )
         try:
             return resp.json()
         except Exception as e:
             raise IntegrationException(
-                _('Error decoding response from Bitbucket: %s') % (e,))
+                _("Error decoding response from Bitbucket: %s") % (e,)
+            )
 
     def get_assignees(self):
         """Gets list of possible assignees"""
-        url = '%(api_url)s/privileges/%(owner)s/%(repo_name)s' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'repo_name': self.repo_name}
+        url = "%(api_url)s/privileges/%(owner)s/%(repo_name)s" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "repo_name": self.repo_name,
+        }
 
         data = self.make_request(url)
-        results = [{'user': self.owner, 'name': '(Repo owner)'}]
+        results = [{"user": self.owner, "name": "(Repo owner)"}]
         if data:
             for entry in data:
-                results.append({"user": entry['user']['username'],
-                                "name": entry['user'].get('display_name')})
+                results.append(
+                    {
+                        "user": entry["user"]["username"],
+                        "name": entry["user"].get("display_name"),
+                    }
+                )
         return results
 
     def create_issue(self, form_data):
         """
         Sends creates a new issue in tracker using REST call
         """
-        url = '%(api_url)s/repositories/%(owner)s/%(repo_name)s/issues/' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'repo_name': self.repo_name}
+        url = "%(api_url)s/repositories/%(owner)s/%(repo_name)s/issues/" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "repo_name": self.repo_name,
+        }
 
         payload = {
-            "title": form_data['title'],
-            "content": form_data['content'],
-            "kind": form_data['kind'],
-            "priority": form_data['priority'],
-            "responsible": form_data['responsible']
+            "title": form_data["title"],
+            "content": form_data["content"],
+            "kind": form_data["kind"],
+            "priority": form_data["priority"],
+            "responsible": form_data["responsible"],
         }
-        data = self.make_request(url, 'post', payload)
+        data = self.make_request(url, "post", payload)
         f_args = {
             "owner": self.owner,
             "repo_name": self.repo_name,
-            "issue_id": data['local_id']
+            "issue_id": data["local_id"],
         }
-        web_url = 'https://bitbucket.org/%(owner)s/%(repo_name)s' \
-                  '/issue/%(issue_id)s/issue-title' % f_args
+        web_url = (
+            "https://bitbucket.org/%(owner)s/%(repo_name)s"
+            "/issue/%(issue_id)s/issue-title" % f_args
+        )
         to_return = {
-            'id': data['local_id'],
-            'resource_url': data['resource_uri'],
-            'web_url': web_url
+            "id": data["local_id"],
+            "resource_url": data["resource_uri"],
+            "web_url": web_url,
         }
         return to_return

backend/src/appenlight/models/integrations/campfire.py

@@ -20,8 +20,7 b' from requests.exceptions import HTTPError, ConnectionError'
 from camplight import Request, Campfire
 from camplight.exceptions import CamplightException
 
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 
 _ = str
 
@@ -33,14 +32,12 b' class NotFoundException(Exception):'
 
 
 class CampfireIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'campfire'
-    }
+    __mapper_args__ = {"polymorphic_identity": "campfire"}
     front_visible = False
     as_alert_channel = True
     supports_report_alerting = True
     action_notification = True
-    integration_action = 'Message via Campfire'
+    integration_action = "Message via Campfire"
 
     @classmethod
     def create_client(cls, api_token, account):
@@ -50,7 +47,7 b' class CampfireIntegration(IntegrationBase):'
 
 class CampfireClient(object):
     def __init__(self, api_token, account):
-        request = Request('https://%s.campfirenow.com' % account, api_token)
+        request = Request("https://%s.campfirenow.com" % account, api_token)
         self.campfire = Campfire(request)
 
     def get_account(self):
@@ -65,10 +62,10 b' class CampfireClient(object):'
         except (HTTPError, CamplightException) as e:
             raise IntegrationException(str(e))
 
-    def speak_to_room(self, room, message, sound='RIMSHOT'):
+    def speak_to_room(self, room, message, sound="RIMSHOT"):
         try:
             room = self.campfire.room(room)
             room.join()
-            room.speak(message, type_='TextMessage')
+            room.speak(message, type_="TextMessage")
         except (HTTPError, CamplightException, ConnectionError) as e:
             raise IntegrationException(str(e))

backend/src/appenlight/models/integrations/flowdock.py

@@ -20,8 +20,7 b' import requests'
 from requests.auth import HTTPBasicAuth
 import simplejson as json
 
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 
 _ = str
 
@@ -33,14 +32,12 b' class NotFoundException(Exception):'
 
 
 class FlowdockIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'flowdock'
-    }
+    __mapper_args__ = {"polymorphic_identity": "flowdock"}
     front_visible = False
     as_alert_channel = True
     supports_report_alerting = True
     action_notification = True
-    integration_action = 'Message via Flowdock'
+    integration_action = "Message via Flowdock"
 
     @classmethod
     def create_client(cls, api_token):
@@ -50,33 +47,37 b' class FlowdockIntegration(IntegrationBase):'
 
 class FlowdockClient(object):
     def __init__(self, api_token):
-        self.auth = HTTPBasicAuth(api_token, '')
+        self.auth = HTTPBasicAuth(api_token, "")
         self.api_token = api_token
-        self.api_url = 'https://api.flowdock.com/v1/messages'
+        self.api_url = "https://api.flowdock.com/v1/messages"
 
-    def make_request(self, url, method='get', data=None):
+    def make_request(self, url, method="get", data=None):
         headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': 'appenlight-flowdock',
+            "Content-Type": "application/json",
+            "User-Agent": "appenlight-flowdock",
         }
         try:
             if data:
                 data = json.dumps(data)
-            resp = getattr(requests, method)(url, data=data, headers=headers,
-                                             timeout=10)
+            resp = getattr(requests, method)(
+                url, data=data, headers=headers, timeout=10
+            )
         except Exception as e:
             raise IntegrationException(
-                _('Error communicating with Flowdock: %s') % (e,))
+                _("Error communicating with Flowdock: %s") % (e,)
+            )
         if resp.status_code > 299:
             raise IntegrationException(resp.text)
         return resp
 
     def send_to_chat(self, payload):
-        url = '%(api_url)s/chat/%(api_token)s' % {'api_url': self.api_url,
-                                                  'api_token': self.api_token}
-        return self.make_request(url, method='post', data=payload).json()
+        url = "%(api_url)s/chat/%(api_token)s" % {
+            "api_url": self.api_url,
+            "api_token": self.api_token,
+        }
+        return self.make_request(url, method="post", data=payload).json()
 
     def send_to_inbox(self, payload):
-        f_args = {'api_url': self.api_url, 'api_token': self.api_token}
-        url = '%(api_url)s/team_inbox/%(api_token)s' % f_args
-        return self.make_request(url, method='post', data=payload).json()
+        f_args = {"api_url": self.api_url, "api_token": self.api_token}
+        url = "%(api_url)s/team_inbox/%(api_token)s" % f_args
+        return self.make_request(url, method="post", data=payload).json()

backend/src/appenlight/models/integrations/github.py

@@ -27,14 +27,12 b' class GithubAuthException(Exception):'
 
 
 class GithubIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'github'
-    }
+    __mapper_args__ = {"polymorphic_identity": "github"}
     front_visible = True
     as_alert_channel = False
     supports_report_alerting = False
     action_notification = True
-    integration_action = 'Add issue to Github'
+    integration_action = "Add issue to Github"
 
     @classmethod
     def create_client(cls, request, user_name=None, repo_name=None):
@@ -45,112 +43,116 b' class GithubIntegration(IntegrationBase):'
         token = None
         secret = None
         for identity in request.user.external_identities:
-            if identity.provider_name == 'github':
+            if identity.provider_name == "github":
                 token = identity.access_token
                 secret = identity.token_secret
                 break
         if not token:
-            raise IntegrationException(
-                'No valid auth token present for this service')
+            raise IntegrationException("No valid auth token present for this service")
         client = GithubClient(token=token, owner=user_name, name=repo_name)
         return client
 
 
 class GithubClient(object):
-    api_url = 'https://api.github.com'
-    repo_type = 'github'
+    api_url = "https://api.github.com"
+    repo_type = "github"
 
     def __init__(self, token, owner, name):
         self.access_token = token
         self.owner = owner
         self.name = name
 
-    def make_request(self, url, method='get', data=None, headers=None):
-        req_headers = {'User-Agent': 'appenlight',
-                       'Content-Type': 'application/json',
-                       'Authorization': 'token %s' % self.access_token}
+    def make_request(self, url, method="get", data=None, headers=None):
+        req_headers = {
+            "User-Agent": "appenlight",
+            "Content-Type": "application/json",
+            "Authorization": "token %s" % self.access_token,
+        }
         try:
             if data:
                 data = json.dumps(data)
-            resp = getattr(requests, method)(url, data=data,
-                                             headers=req_headers,
-                                             timeout=10)
+            resp = getattr(requests, method)(
+                url, data=data, headers=req_headers, timeout=10
+            )
         except Exception as e:
-            msg = 'Error communicating with Github: %s'
+            msg = "Error communicating with Github: %s"
             raise IntegrationException(_(msg) % (e,))
 
         if resp.status_code == 404:
-            msg = 'User or repo name are incorrect'
+            msg = "User or repo name are incorrect"
             raise IntegrationException(_(msg))
         if resp.status_code == 401:
-            msg = 'You are not authorized to access this repo'
+            msg = "You are not authorized to access this repo"
             raise IntegrationException(_(msg))
         elif resp.status_code not in [200, 201]:
-            msg = 'Github response_code: %s'
+            msg = "Github response_code: %s"
             raise IntegrationException(_(msg) % resp.status_code)
         try:
             return resp.json()
         except Exception as e:
-            msg = 'Error decoding response from Github: %s'
+            msg = "Error decoding response from Github: %s"
             raise IntegrationException(_(msg) % (e,))
 
     def get_statuses(self):
         """Gets list of possible item statuses"""
-        url = '%(api_url)s/repos/%(owner)s/%(name)s/labels' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'name': self.name}
+        url = "%(api_url)s/repos/%(owner)s/%(name)s/labels" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "name": self.name,
+        }
 
         data = self.make_request(url)
 
         statuses = []
         for status in data:
-            statuses.append(status['name'])
+            statuses.append(status["name"])
         return statuses
 
     def get_repo(self):
         """Gets list of possible item statuses"""
-        url = '%(api_url)s/repos/%(owner)s/%(name)s' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'name': self.name}
+        url = "%(api_url)s/repos/%(owner)s/%(name)s" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "name": self.name,
+        }
 
         data = self.make_request(url)
         return data
 
     def get_assignees(self):
         """Gets list of possible assignees"""
-        url = '%(api_url)s/repos/%(owner)s/%(name)s/collaborators' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'name': self.name}
+        url = "%(api_url)s/repos/%(owner)s/%(name)s/collaborators" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "name": self.name,
+        }
         data = self.make_request(url)
         results = []
         for entry in data:
-            results.append({"user": entry['login'],
-                            "name": entry.get('name')})
+            results.append({"user": entry["login"], "name": entry.get("name")})
         return results
 
     def create_issue(self, form_data):
         """
         Make a REST call to create issue in Github's issue tracker
         """
-        url = '%(api_url)s/repos/%(owner)s/%(name)s/issues' % {
-            'api_url': self.api_url,
-            'owner': self.owner,
-            'name': self.name}
+        url = "%(api_url)s/repos/%(owner)s/%(name)s/issues" % {
+            "api_url": self.api_url,
+            "owner": self.owner,
+            "name": self.name,
+        }
 
         payload = {
-            "title": form_data['title'],
-            "body": form_data['content'],
+            "title": form_data["title"],
+            "body": form_data["content"],
             "labels": [],
-            "assignee": form_data['responsible']
+            "assignee": form_data["responsible"],
         }
-        payload['labels'].extend(form_data['kind'])
-        data = self.make_request(url, 'post', data=payload)
+        payload["labels"].extend(form_data["kind"])
+        data = self.make_request(url, "post", data=payload)
         to_return = {
-            'id': data['number'],
-            'resource_url': data['url'],
-            'web_url': data['html_url']
+            "id": data["number"],
+            "resource_url": data["url"],
+            "web_url": data["html_url"],
         }
         return to_return

backend/src/appenlight/models/integrations/hipchat.py

@@ -30,14 +30,12 b' class NotFoundException(Exception):'
 
 
 class HipchatIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'hipchat'
-    }
+    __mapper_args__ = {"polymorphic_identity": "hipchat"}
     front_visible = False
     as_alert_channel = True
     supports_report_alerting = True
     action_notification = True
-    integration_action = 'Message via Hipchat'
+    integration_action = "Message via Hipchat"
 
     @classmethod
     def create_client(cls, api_token):
@@ -48,36 +46,30 b' class HipchatIntegration(IntegrationBase):'
 class HipchatClient(object):
     def __init__(self, api_token):
         self.api_token = api_token
-        self.api_url = 'https://api.hipchat.com/v1'
-
-    def make_request(self, endpoint, method='get', data=None):
-        headers = {
-            'User-Agent': 'appenlight-hipchat',
-        }
-        url = '%s%s' % (self.api_url, endpoint)
-        params = {
-            'format': 'json',
-            'auth_token': self.api_token
-        }
+        self.api_url = "https://api.hipchat.com/v1"
+
+    def make_request(self, endpoint, method="get", data=None):
+        headers = {"User-Agent": "appenlight-hipchat"}
+        url = "%s%s" % (self.api_url, endpoint)
+        params = {"format": "json", "auth_token": self.api_token}
         try:
-            resp = getattr(requests, method)(url, data=data, headers=headers,
-                                             params=params,
-                                             timeout=3)
+            resp = getattr(requests, method)(
+                url, data=data, headers=headers, params=params, timeout=3
+            )
         except Exception as e:
-            msg = 'Error communicating with Hipchat: %s'
+            msg = "Error communicating with Hipchat: %s"
             raise IntegrationException(_(msg) % (e,))
         if resp.status_code == 404:
-            msg = 'Error communicating with Hipchat - Room not found'
+            msg = "Error communicating with Hipchat - Room not found"
             raise IntegrationException(msg)
         elif resp.status_code != requests.codes.ok:
-            msg = 'Error communicating with Hipchat - status code: %s'
+            msg = "Error communicating with Hipchat - status code: %s"
             raise IntegrationException(msg % resp.status_code)
         return resp
 
     def get_rooms(self):
         # not used with notification api token
-        return self.make_request('/rooms/list')
+        return self.make_request("/rooms/list")
 
     def send(self, payload):
-        return self.make_request('/rooms/message', method='post',
-                                 data=payload).json()
+        return self.make_request("/rooms/message", method="post", data=payload).json()

backend/src/appenlight/models/integrations/jira.py

@@ -15,8 +15,7 b''
 # limitations under the License.
 
 import jira
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 
 _ = str
 
@@ -26,14 +25,12 b' class NotFoundException(Exception):'
 
 
 class JiraIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'jira'
-    }
+    __mapper_args__ = {"polymorphic_identity": "jira"}
     front_visible = True
     as_alert_channel = False
     supports_report_alerting = False
     action_notification = True
-    integration_action = 'Add issue to Jira'
+    integration_action = "Add issue to Jira"
 
 
 class JiraClient(object):
@@ -44,12 +41,14 b' class JiraClient(object):'
         self.project = project
         self.request = request
         try:
-            self.client = jira.client.JIRA(options={'server': host_name},
-                                           basic_auth=(user_name, password))
+            self.client = jira.client.JIRA(
+                options={"server": host_name}, basic_auth=(user_name, password)
+            )
         except jira.JIRAError as e:
             raise IntegrationException(
-                'Communication problem: HTTP_STATUS:%s, URL:%s ' % (
-                    e.status_code, e.url))
+                "Communication problem: HTTP_STATUS:%s, URL:%s "
+                % (e.status_code, e.url)
+            )
 
     def get_projects(self):
         projects = self.client.projects()
@@ -58,42 +57,42 b' class JiraClient(object):'
     def get_assignees(self, request):
         """Gets list of possible assignees"""
         cache_region = request.registry.cache_regions.redis_sec_30
-        @cache_region.cache_on_arguments('JiraClient.get_assignees')
+
+        @cache_region.cache_on_arguments("JiraClient.get_assignees")
         def cached(project_name):
             users = self.client.search_assignable_users_for_issues(
-                None, project=project_name)
+                None, project=project_name
+            )
             results = []
             for user in users:
                 results.append({"id": user.name, "name": user.displayName})
             return results
+
         return cached(self.project)
 
     def get_issue_types(self, request):
         metadata = self.get_metadata(request)
         assignees = self.get_assignees(request)
         parsed_metadata = []
-        for entry in metadata['projects'][0]['issuetypes']:
-            issue = {"name": entry['name'],
-                     "id": entry['id'],
-                     "fields": []}
-            for i_id, field_i in entry['fields'].items():
+        for entry in metadata["projects"][0]["issuetypes"]:
+            issue = {"name": entry["name"], "id": entry["id"], "fields": []}
+            for i_id, field_i in entry["fields"].items():
                 field = {
-                    "name": field_i['name'],
+                    "name": field_i["name"],
                     "id": i_id,
-                    "required": field_i['required'],
+                    "required": field_i["required"],
                     "values": [],
-                    "type": field_i['schema'].get('type')
+                    "type": field_i["schema"].get("type"),
                 }
-                if field_i.get('allowedValues'):
-                    field['values'] = []
-                    for i in field_i['allowedValues']:
-                        field['values'].append(
-                            {'id': i['id'],
-                             'name': i.get('name', i.get('value', ''))
-                             })
-                if field['id'] == 'assignee':
-                    field['values'] = assignees
-                issue['fields'].append(field)
+                if field_i.get("allowedValues"):
+                    field["values"] = []
+                    for i in field_i["allowedValues"]:
+                        field["values"].append(
+                            {"id": i["id"], "name": i.get("name", i.get("value", ""))}
+                        )
+                if field["id"] == "assignee":
+                    field["values"] = assignees
+                issue["fields"].append(field)
             parsed_metadata.append(issue)
         return parsed_metadata
 
@@ -102,35 +101,37 b' class JiraClient(object):'
         # @cache_region.cache_on_arguments('JiraClient.get_metadata')
         def cached(project_name):
             return self.client.createmeta(
-                projectKeys=project_name, expand='projects.issuetypes.fields')
+                projectKeys=project_name, expand="projects.issuetypes.fields"
+            )
+
         return cached(self.project)
 
     def create_issue(self, form_data, request):
         issue_types = self.get_issue_types(request)
         payload = {
-            'project': {'key': form_data['project']},
-            'summary': form_data['title'],
-            'description': form_data['content'],
-            'issuetype': {'id': form_data['issue_type']},
-            "priority": {'id': form_data['priority']},
-            "assignee": {'name': form_data['responsible']},
+            "project": {"key": form_data["project"]},
+            "summary": form_data["title"],
+            "description": form_data["content"],
+            "issuetype": {"id": form_data["issue_type"]},
+            "priority": {"id": form_data["priority"]},
+            "assignee": {"name": form_data["responsible"]},
         }
         for issue_type in issue_types:
-            if issue_type['id'] == form_data['issue_type']:
-                for field in issue_type['fields']:
+            if issue_type["id"] == form_data["issue_type"]:
+                for field in issue_type["fields"]:
                     # set some defaults for other required fields
-                    if field == 'reporter':
-                        payload["reporter"] = {'id': self.user_name}
-                    if field['required'] and field['id'] not in payload:
-                        if field['type'] == 'array':
-                            payload[field['id']] = [field['values'][0], ]
-                        elif field['type'] == 'string':
-                            payload[field['id']] = ''
+                    if field == "reporter":
+                        payload["reporter"] = {"id": self.user_name}
+                    if field["required"] and field["id"] not in payload:
+                        if field["type"] == "array":
+                            payload[field["id"]] = [field["values"][0]]
+                        elif field["type"] == "string":
+                            payload[field["id"]] = ""
         new_issue = self.client.create_issue(fields=payload)
-        web_url = self.host_name + '/browse/' + new_issue.key
+        web_url = self.host_name + "/browse/" + new_issue.key
         to_return = {
-            'id': new_issue.id,
-            'resource_url': new_issue.self,
-            'web_url': web_url
+            "id": new_issue.id,
+            "resource_url": new_issue.self,
+            "web_url": web_url,
         }
         return to_return

backend/src/appenlight/models/integrations/slack.py

@@ -18,8 +18,7 b' import logging'
 
 import requests
 
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 from appenlight.lib.ext_json import json
 
 _ = str
@@ -32,14 +31,12 b' class NotFoundException(Exception):'
 
 
 class SlackIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'slack'
-    }
+    __mapper_args__ = {"polymorphic_identity": "slack"}
     front_visible = False
     as_alert_channel = True
     supports_report_alerting = True
     action_notification = True
-    integration_action = 'Message via Slack'
+    integration_action = "Message via Slack"
 
     @classmethod
     def create_client(cls, api_token):
@@ -52,23 +49,17 b' class SlackClient(object):'
         self.api_url = api_url
 
     def make_request(self, data=None):
-        headers = {
-            'User-Agent': 'appenlight-slack',
-            'Content-Type': 'application/json'
-        }
+        headers = {"User-Agent": "appenlight-slack", "Content-Type": "application/json"}
         try:
-            resp = getattr(requests, 'post')(self.api_url,
-                                             data=json.dumps(data),
-                                             headers=headers,
-                                             timeout=3)
+            resp = getattr(requests, "post")(
+                self.api_url, data=json.dumps(data), headers=headers, timeout=3
+            )
         except Exception as e:
-            raise IntegrationException(
-                _('Error communicating with Slack: %s') % (e,))
+            raise IntegrationException(_("Error communicating with Slack: %s") % (e,))
         if resp.status_code != requests.codes.ok:
-            msg = 'Error communicating with Slack - status code: %s'
+            msg = "Error communicating with Slack - status code: %s"
             raise IntegrationException(msg % resp.status_code)
         return resp
 
     def send(self, payload):
-        return self.make_request('/rooms/message', method='post',
-                                 data=payload).json()
+        return self.make_request("/rooms/message", method="post", data=payload).json()

backend/src/appenlight/models/integrations/webhooks.py

@@ -18,8 +18,7 b' import logging'
 
 import requests
 
-from appenlight.models.integrations import (IntegrationBase,
-                                            IntegrationException)
+from appenlight.models.integrations import IntegrationBase, IntegrationException
 from appenlight.models.alert_channel import AlertChannel
 from appenlight.lib.ext_json import json
 
@@ -33,14 +32,12 b' class NotFoundException(Exception):'
 
 
 class WebhooksIntegration(IntegrationBase):
-    __mapper_args__ = {
-        'polymorphic_identity': 'webhooks'
-    }
+    __mapper_args__ = {"polymorphic_identity": "webhooks"}
     front_visible = False
     as_alert_channel = True
     supports_report_alerting = True
     action_notification = True
-    integration_action = 'Message via Webhooks'
+    integration_action = "Message via Webhooks"
 
     @classmethod
     def create_client(cls, url):
@@ -52,34 +49,33 b' class WebhooksClient(object):'
     def __init__(self, url):
         self.api_url = url
 
-    def make_request(self, url, method='get', data=None):
+    def make_request(self, url, method="get", data=None):
         headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': 'appenlight-webhooks',
+            "Content-Type": "application/json",
+            "User-Agent": "appenlight-webhooks",
         }
         try:
             if data:
                 data = json.dumps(data)
-            resp = getattr(requests, method)(url, data=data, headers=headers,
-                                             timeout=3)
+            resp = getattr(requests, method)(url, data=data, headers=headers, timeout=3)
         except Exception as e:
             raise IntegrationException(
-                _('Error communicating with Webhooks: {}').format(e))
+                _("Error communicating with Webhooks: {}").format(e)
+            )
         if resp.status_code > 299:
             raise IntegrationException(
-                'Error communicating with Webhooks - status code: {}'.format(
-                    resp.status_code))
+                "Error communicating with Webhooks - status code: {}".format(
+                    resp.status_code
+                )
+            )
         return resp
 
     def send_to_hook(self, payload):
-        return self.make_request(self.api_url, method='post',
-                                 data=payload).json()
+        return self.make_request(self.api_url, method="post", data=payload).json()
 
 
 class WebhooksAlertChannel(AlertChannel):
-    __mapper_args__ = {
-        'polymorphic_identity': 'webhooks'
-    }
+    __mapper_args__ = {"polymorphic_identity": "webhooks"}
 
     def notify_reports(self, **kwargs):
         """
@@ -95,17 +91,28 b' class WebhooksAlertChannel(AlertChannel):'
         """
         template_vars = self.get_notification_basic_vars(kwargs)
         payload = []
-        include_keys = ('id', 'http_status', 'report_type', 'resource_name',
-                        'front_url', 'resource_id', 'error', 'url_path',
-                        'tags', 'duration')
-
-        for occurences, report in kwargs['reports']:
-            r_dict = report.last_report_ref.get_dict(kwargs['request'],
-                                                     include_keys=include_keys)
-            r_dict['group']['occurences'] = occurences
+        include_keys = (
+            "id",
+            "http_status",
+            "report_type",
+            "resource_name",
+            "front_url",
+            "resource_id",
+            "error",
+            "url_path",
+            "tags",
+            "duration",
+        )
+
+        for occurences, report in kwargs["reports"]:
+            r_dict = report.last_report_ref.get_dict(
+                kwargs["request"], include_keys=include_keys
+            )
+            r_dict["group"]["occurences"] = occurences
             payload.append(r_dict)
         client = WebhooksIntegration.create_client(
-            self.integration.config['reports_webhook'])
+            self.integration.config["reports_webhook"]
+        )
         client.send_to_hook(payload)
 
     def notify_alert(self, **kwargs):
@@ -120,19 +127,19 b' class WebhooksAlertChannel(AlertChannel):'
 
         """
         payload = {
-            'alert_action': kwargs['event'].unified_alert_action(),
-            'alert_name': kwargs['event'].unified_alert_name(),
-            'event_time': kwargs['event'].end_date or kwargs[
-                'event'].start_date,
-            'resource_name': None,
-            'resource_id': None
+            "alert_action": kwargs["event"].unified_alert_action(),
+            "alert_name": kwargs["event"].unified_alert_name(),
+            "event_time": kwargs["event"].end_date or kwargs["event"].start_date,
+            "resource_name": None,
+            "resource_id": None,
         }
-        if kwargs['event'].values and kwargs['event'].values.get('reports'):
-            payload['reports'] = kwargs['event'].values.get('reports', [])
-        if 'application' in kwargs:
-            payload['resource_name'] = kwargs['application'].resource_name
-            payload['resource_id'] = kwargs['application'].resource_id
+        if kwargs["event"].values and kwargs["event"].values.get("reports"):
+            payload["reports"] = kwargs["event"].values.get("reports", [])
+        if "application" in kwargs:
+            payload["resource_name"] = kwargs["application"].resource_name
+            payload["resource_id"] = kwargs["application"].resource_id
 
         client = WebhooksIntegration.create_client(
-            self.integration.config['alerts_webhook'])
+            self.integration.config["alerts_webhook"]
+        )
         client.send_to_hook(payload)

backend/src/appenlight/models/log.py

@@ -29,21 +29,23 b' log = logging.getLogger(__name__)'
 
 
 class Log(Base, BaseModel):
-    __tablename__ = 'logs'
-    __table_args__ = {'implicit_returning': False}
+    __tablename__ = "logs"
+    __table_args__ = {"implicit_returning": False}
 
     log_id = sa.Column(sa.BigInteger(), nullable=False, primary_key=True)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('applications.resource_id',
-                                          onupdate='CASCADE',
-                                          ondelete='CASCADE'),
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey(
+            "applications.resource_id", onupdate="CASCADE", ondelete="CASCADE"
+        ),
                             nullable=False,
-                            index=True)
-    log_level = sa.Column(sa.Unicode, nullable=False, index=True,
-                          default='INFO')
-    message = sa.Column(sa.UnicodeText(), default='')
-    timestamp = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                          server_default=sa.func.now())
+        index=True,
+    )
+    log_level = sa.Column(sa.Unicode, nullable=False, index=True, default="INFO")
+    message = sa.Column(sa.UnicodeText(), default="")
+    timestamp = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
     request_id = sa.Column(sa.Unicode())
     namespace = sa.Column(sa.Unicode())
     primary_key = sa.Column(sa.Unicode())
@@ -52,39 +54,40 b' class Log(Base, BaseModel):'
     permanent = sa.Column(sa.Boolean(), nullable=False, default=False)
 
     def __str__(self):
-        return self.__unicode__().encode('utf8')
+        return self.__unicode__().encode("utf8")
 
     def __unicode__(self):
-        return '<Log id:%s, lv:%s, ns:%s >' % (
-            self.log_id, self.log_level, self.namespace)
+        return "<Log id:%s, lv:%s, ns:%s >" % (
+            self.log_id,
+            self.log_level,
+            self.namespace,
+        )
 
     def set_data(self, data, resource):
-        level = data.get('log_level').upper()
+        level = data.get("log_level").upper()
         self.log_level = getattr(LogLevel, level, LogLevel.UNKNOWN)
-        self.message = data.get('message', '')
-        server_name = data.get('server', '').lower() or 'unknown'
-        self.tags = {
-            'server_name': server_name
-        }
-        if data.get('tags'):
-            for tag_tuple in data['tags']:
+        self.message = data.get("message", "")
+        server_name = data.get("server", "").lower() or "unknown"
+        self.tags = {"server_name": server_name}
+        if data.get("tags"):
+            for tag_tuple in data["tags"]:
                 self.tags[tag_tuple[0]] = tag_tuple[1]
-        self.timestamp = data['date']
-        r_id = data.get('request_id', '')
+        self.timestamp = data["date"]
+        r_id = data.get("request_id", "")
         if not r_id:
-            r_id = ''
-        self.request_id = r_id.replace('-', '')
+            r_id = ""
+        self.request_id = r_id.replace("-", "")
         self.resource_id = resource.resource_id
-        self.namespace = data.get('namespace') or ''
-        self.permanent = data.get('permanent')
-        self.primary_key = data.get('primary_key')
+        self.namespace = data.get("namespace") or ""
+        self.permanent = data.get("permanent")
+        self.primary_key = data.get("primary_key")
         if self.primary_key is not None:
-            self.tags['appenlight_primary_key'] = self.primary_key
+            self.tags["appenlight_primary_key"] = self.primary_key
 
     def get_dict(self):
         instance_dict = super(Log, self).get_dict()
-        instance_dict['log_level'] = LogLevel.key_from_value(self.log_level)
-        instance_dict['resource_name'] = self.application.resource_name
+        instance_dict["log_level"] = LogLevel.key_from_value(self.log_level)
+        instance_dict["resource_name"] = self.application.resource_name
         return instance_dict
 
     @property
@@ -92,39 +95,38 b' class Log(Base, BaseModel):'
         if not self.primary_key:
             return None
 
-        to_hash = '{}_{}_{}'.format(self.resource_id, self.primary_key,
-                                    self.namespace)
-        return hashlib.sha1(to_hash.encode('utf8')).hexdigest()
+        to_hash = "{}_{}_{}".format(self.resource_id, self.primary_key, self.namespace)
+        return hashlib.sha1(to_hash.encode("utf8")).hexdigest()
 
     def es_doc(self):
         tags = {}
         tag_list = []
         for name, value in self.tags.items():
             # replace dot in indexed tag name
-            name = name.replace('.', '_')
+            name = name.replace(".", "_")
             tag_list.append(name)
             tags[name] = {
                 "values": convert_es_type(value),
-                "numeric_values": value if (
-                    isinstance(value, (int, float)) and
-                    not isinstance(value, bool)) else None
+                "numeric_values": value
+                if (isinstance(value, (int, float)) and not isinstance(value, bool))
+                else None,
             }
         return {
-            'pg_id': str(self.log_id),
-            'delete_hash': self.delete_hash,
-            'resource_id': self.resource_id,
-            'request_id': self.request_id,
-            'log_level': LogLevel.key_from_value(self.log_level),
-            'timestamp': self.timestamp,
-            'message': self.message if self.message else '',
-            'namespace': self.namespace if self.namespace else '',
-            'tags': tags,
-            'tag_list': tag_list
+            "pg_id": str(self.log_id),
+            "delete_hash": self.delete_hash,
+            "resource_id": self.resource_id,
+            "request_id": self.request_id,
+            "log_level": LogLevel.key_from_value(self.log_level),
+            "timestamp": self.timestamp,
+            "message": self.message if self.message else "",
+            "namespace": self.namespace if self.namespace else "",
+            "tags": tags,
+            "tag_list": tag_list,
         }
 
     @property
     def partition_id(self):
         if self.permanent:
-            return 'rcae_l_%s' % self.timestamp.strftime('%Y_%m')
+            return "rcae_l_%s" % self.timestamp.strftime("%Y_%m")
         else:
-            return 'rcae_l_%s' % self.timestamp.strftime('%Y_%m_%d')
+            return "rcae_l_%s" % self.timestamp.strftime("%Y_%m_%d")

backend/src/appenlight/models/metric.py

@@ -25,40 +25,44 b' from appenlight.models import Base'
 
 
 class Metric(Base, BaseModel):
-    __tablename__ = 'metrics'
-    __table_args__ = {'implicit_returning': False}
+    __tablename__ = "metrics"
+    __table_args__ = {"implicit_returning": False}
 
     pkey = sa.Column(sa.BigInteger(), primary_key=True)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('applications.resource_id'),
-                            nullable=False, primary_key=True)
-    timestamp = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                          server_default=sa.func.now())
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey("applications.resource_id"),
+        nullable=False,
+        primary_key=True,
+    )
+    timestamp = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
     tags = sa.Column(JSON(), default={})
     namespace = sa.Column(sa.Unicode(255))
 
     @property
     def partition_id(self):
-        return 'rcae_m_%s' % self.timestamp.strftime('%Y_%m_%d')
+        return "rcae_m_%s" % self.timestamp.strftime("%Y_%m_%d")
 
     def es_doc(self):
         tags = {}
         tag_list = []
         for name, value in self.tags.items():
             # replace dot in indexed tag name
-            name = name.replace('.', '_')
+            name = name.replace(".", "_")
             tag_list.append(name)
             tags[name] = {
                 "values": convert_es_type(value),
-                "numeric_values": value if (
-                    isinstance(value, (int, float)) and
-                    not isinstance(value, bool)) else None
+                "numeric_values": value
+                if (isinstance(value, (int, float)) and not isinstance(value, bool))
+                else None,
             }
 
         return {
-            'resource_id': self.resource_id,
-            'timestamp': self.timestamp,
-            'namespace': self.namespace,
-            'tags': tags,
-            'tag_list': tag_list
+            "resource_id": self.resource_id,
+            "timestamp": self.timestamp,
+            "namespace": self.namespace,
+            "tags": tags,
+            "tag_list": tag_list,
         }

backend/src/appenlight/models/plugin_config.py

@@ -22,19 +22,19 b' from . import Base'
 
 
 class PluginConfig(Base, BaseModel):
-    __tablename__ = 'plugin_configs'
+    __tablename__ = "plugin_configs"
 
     id = sa.Column(sa.Integer, primary_key=True)
     plugin_name = sa.Column(sa.Unicode)
     section = sa.Column(sa.Unicode)
     config = sa.Column(JSON, nullable=False)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('resources.resource_id',
-                                          onupdate='cascade',
-                                          ondelete='cascade'))
-    owner_id = sa.Column(sa.Integer(),
-                         sa.ForeignKey('users.id', onupdate='cascade',
-                                       ondelete='cascade'))
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey("resources.resource_id", onupdate="cascade", ondelete="cascade"),
+    )
+    owner_id = sa.Column(
+        sa.Integer(), sa.ForeignKey("users.id", onupdate="cascade", ondelete="cascade")
+    )
 
     def __json__(self, request):
         return self.get_dict()

backend/src/appenlight/models/report.py

@@ -36,51 +36,55 b' from ziggurat_foundations.models.base import BaseModel'
 log = logging.getLogger(__name__)
 
 REPORT_TYPE_MATRIX = {
-    'http_status': {"type": 'int',
-                    "ops": ('eq', 'ne', 'ge', 'le',)},
-    'group:priority': {"type": 'int',
-                       "ops": ('eq', 'ne', 'ge', 'le',)},
-    'duration': {"type": 'float',
-                 "ops": ('ge', 'le',)},
-    'url_domain': {"type": 'unicode',
-                   "ops": ('eq', 'ne', 'startswith', 'endswith', 'contains',)},
-    'url_path': {"type": 'unicode',
-                 "ops": ('eq', 'ne', 'startswith', 'endswith', 'contains',)},
-    'error': {"type": 'unicode',
-              "ops": ('eq', 'ne', 'startswith', 'endswith', 'contains',)},
-    'tags:server_name': {"type": 'unicode',
-                         "ops": ('eq', 'ne', 'startswith', 'endswith',
-                                 'contains',)},
-    'traceback': {"type": 'unicode',
-                  "ops": ('contains',)},
-    'group:occurences': {"type": 'int',
-                         "ops": ('eq', 'ne', 'ge', 'le',)}
+    "http_status": {"type": "int", "ops": ("eq", "ne", "ge", "le")},
+    "group:priority": {"type": "int", "ops": ("eq", "ne", "ge", "le")},
+    "duration": {"type": "float", "ops": ("ge", "le")},
+    "url_domain": {
+        "type": "unicode",
+        "ops": ("eq", "ne", "startswith", "endswith", "contains"),
+    },
+    "url_path": {
+        "type": "unicode",
+        "ops": ("eq", "ne", "startswith", "endswith", "contains"),
+    },
+    "error": {
+        "type": "unicode",
+        "ops": ("eq", "ne", "startswith", "endswith", "contains"),
+    },
+    "tags:server_name": {
+        "type": "unicode",
+        "ops": ("eq", "ne", "startswith", "endswith", "contains"),
+    },
+    "traceback": {"type": "unicode", "ops": ("contains",)},
+    "group:occurences": {"type": "int", "ops": ("eq", "ne", "ge", "le")},
 }
 
 
 class Report(Base, BaseModel):
-    __tablename__ = 'reports'
-    __table_args__ = {'implicit_returning': False}
+    __tablename__ = "reports"
+    __table_args__ = {"implicit_returning": False}
 
     id = sa.Column(sa.Integer, nullable=False, primary_key=True)
-    group_id = sa.Column(sa.BigInteger,
-                         sa.ForeignKey('reports_groups.id', ondelete='cascade',
-                                       onupdate='cascade'))
+    group_id = sa.Column(
+        sa.BigInteger,
+        sa.ForeignKey("reports_groups.id", ondelete="cascade", onupdate="cascade"),
+    )
     resource_id = sa.Column(sa.Integer(), nullable=False, index=True)
     report_type = sa.Column(sa.Integer(), nullable=False, index=True)
     error = sa.Column(sa.UnicodeText(), index=True)
     extra = sa.Column(JSON(), default={})
     request = sa.Column(JSON(), nullable=False, default={})
-    ip = sa.Column(sa.String(39), index=True, default='')
-    username = sa.Column(sa.Unicode(255), default='')
-    user_agent = sa.Column(sa.Unicode(255), default='')
+    ip = sa.Column(sa.String(39), index=True, default="")
+    username = sa.Column(sa.Unicode(255), default="")
+    user_agent = sa.Column(sa.Unicode(255), default="")
     url = sa.Column(sa.UnicodeText(), index=True)
     request_id = sa.Column(sa.Text())
     request_stats = sa.Column(JSON(), nullable=False, default={})
     traceback = sa.Column(JSON(), nullable=False, default=None)
     traceback_hash = sa.Column(sa.Text())
-    start_time = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                           server_default=sa.func.now())
+    start_time = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
     end_time = sa.Column(sa.DateTime())
     duration = sa.Column(sa.Float, default=0)
     http_status = sa.Column(sa.Integer, index=True)
@@ -89,99 +93,104 b' class Report(Base, BaseModel):'
     tags = sa.Column(JSON(), nullable=False, default={})
     language = sa.Column(sa.Integer(), default=0)
     # this is used to determine partition for the report
-    report_group_time = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                                  server_default=sa.func.now())
+    report_group_time = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
 
     logs = sa.orm.relationship(
-        'Log',
-        lazy='dynamic',
+        "Log",
+        lazy="dynamic",
         passive_deletes=True,
         passive_updates=True,
         primaryjoin="and_(Report.request_id==Log.request_id, "
                     "Log.request_id != None, Log.request_id != '')",
-        foreign_keys='[Log.request_id]')
+        foreign_keys="[Log.request_id]",
+    )
 
-    slow_calls = sa.orm.relationship('SlowCall',
-                                     backref='detail',
+    slow_calls = sa.orm.relationship(
+        "SlowCall",
+        backref="detail",
                                      cascade="all, delete-orphan",
                                      passive_deletes=True,
                                      passive_updates=True,
-                                     order_by='SlowCall.timestamp')
+        order_by="SlowCall.timestamp",
+    )
 
     def set_data(self, data, resource, protocol_version=None):
-        self.http_status = data['http_status']
-        self.priority = data['priority']
-        self.error = data['error']
-        report_language = data.get('language', '').lower()
+        self.http_status = data["http_status"]
+        self.priority = data["priority"]
+        self.error = data["error"]
+        report_language = data.get("language", "").lower()
         self.language = getattr(Language, report_language, Language.unknown)
         # we need temp holder here to decide later
         # if we want to to commit the tags if report is marked for creation
-        self.tags = {
-            'server_name': data['server'],
-            'view_name': data['view_name']
-        }
-        if data.get('tags'):
-            for tag_tuple in data['tags']:
+        self.tags = {"server_name": data["server"], "view_name": data["view_name"]}
+        if data.get("tags"):
+            for tag_tuple in data["tags"]:
                 self.tags[tag_tuple[0]] = tag_tuple[1]
-        self.traceback = data['traceback']
+        self.traceback = data["traceback"]
         stripped_traceback = self.stripped_traceback()
-        tb_repr = repr(stripped_traceback).encode('utf8')
+        tb_repr = repr(stripped_traceback).encode("utf8")
         self.traceback_hash = hashlib.sha1(tb_repr).hexdigest()
-        url_info = urllib.parse.urlsplit(
-            data.get('url', ''), allow_fragments=False)
+        url_info = urllib.parse.urlsplit(data.get("url", ""), allow_fragments=False)
         self.url_domain = url_info.netloc[:128]
         self.url_path = url_info.path[:2048]
-        self.occurences = data['occurences']
+        self.occurences = data["occurences"]
         if self.error:
             self.report_type = ReportType.error
         else:
             self.report_type = ReportType.slow
 
         # but if its status 404 its 404 type
-        if self.http_status in [404, '404'] or self.error == '404 Not Found':
+        if self.http_status in [404, "404"] or self.error == "404 Not Found":
             self.report_type = ReportType.not_found
-            self.error = ''
+            self.error = ""
 
-        self.generate_grouping_hash(data.get('appenlight.group_string',
-                                             data.get('group_string')),
+        self.generate_grouping_hash(
+            data.get("appenlight.group_string", data.get("group_string")),
                                     resource.default_grouping,
-                                    protocol_version)
+            protocol_version,
+        )
 
         # details
-        if data['http_status'] in [404, '404']:
-            data = {"username": data["username"],
+        if data["http_status"] in [404, "404"]:
+            data = {
+                "username": data["username"],
                     "ip": data["ip"],
                     "url": data["url"],
-                    "user_agent": data["user_agent"]}
-            if data.get('HTTP_REFERER') or data.get('http_referer'):
-                data['HTTP_REFERER'] = data.get(
-                    'HTTP_REFERER', '') or data.get('http_referer', '')
+                "user_agent": data["user_agent"],
+            }
+            if data.get("HTTP_REFERER") or data.get("http_referer"):
+                data["HTTP_REFERER"] = data.get("HTTP_REFERER", "") or data.get(
+                    "http_referer", ""
+                )
 
         self.resource_id = resource.resource_id
-        self.username = data['username']
-        self.user_agent = data['user_agent']
-        self.ip = data['ip']
+        self.username = data["username"]
+        self.user_agent = data["user_agent"]
+        self.ip = data["ip"]
         self.extra = {}
-        if data.get('extra'):
-            for extra_tuple in data['extra']:
+        if data.get("extra"):
+            for extra_tuple in data["extra"]:
                 self.extra[extra_tuple[0]] = extra_tuple[1]
 
-        self.url = data['url']
-        self.request_id = data.get('request_id', '').replace('-', '') or str(
-            uuid.uuid4())
-        request_data = data.get('request', {})
+        self.url = data["url"]
+        self.request_id = data.get("request_id", "").replace("-", "") or str(
+            uuid.uuid4()
+        )
+        request_data = data.get("request", {})
 
         self.request = request_data
-        self.request_stats = data.get('request_stats', {})
-        traceback = data.get('traceback')
+        self.request_stats = data.get("request_stats", {})
+        traceback = data.get("traceback")
         if not traceback:
-            traceback = data.get('frameinfo')
+            traceback = data.get("frameinfo")
         self.traceback = traceback
-        start_date = convert_date(data.get('start_time'))
+        start_date = convert_date(data.get("start_time"))
         if not self.start_time or self.start_time < start_date:
             self.start_time = start_date
 
-        self.end_time = convert_date(data.get('end_time'), False)
+        self.end_time = convert_date(data.get("end_time"), False)
         self.duration = 0
 
         if self.start_time and self.end_time:
@@ -190,81 +199,85 b' class Report(Base, BaseModel):'
 
         # update tags with other vars
         if self.username:
-            self.tags['user_name'] = self.username
-        self.tags['report_language'] = Language.key_from_value(self.language)
+            self.tags["user_name"] = self.username
+        self.tags["report_language"] = Language.key_from_value(self.language)
 
     def add_slow_calls(self, data, report_group):
         slow_calls = []
-        for call in data.get('slow_calls', []):
+        for call in data.get("slow_calls", []):
             sc_inst = SlowCall()
-            sc_inst.set_data(call, resource_id=self.resource_id,
-                             report_group=report_group)
+            sc_inst.set_data(
+                call, resource_id=self.resource_id, report_group=report_group
+            )
             slow_calls.append(sc_inst)
             self.slow_calls.extend(slow_calls)
         return slow_calls
 
-    def get_dict(self, request, details=False, exclude_keys=None,
-                 include_keys=None):
+    def get_dict(self, request, details=False, exclude_keys=None, include_keys=None):
         from appenlight.models.services.report_group import ReportGroupService
-        instance_dict = super(Report, self).get_dict()
-        instance_dict['req_stats'] = self.req_stats()
-        instance_dict['group'] = {}
-        instance_dict['group']['id'] = self.report_group.id
-        instance_dict['group'][
-            'total_reports'] = self.report_group.total_reports
-        instance_dict['group']['last_report'] = self.report_group.last_report
-        instance_dict['group']['priority'] = self.report_group.priority
-        instance_dict['group']['occurences'] = self.report_group.occurences
-        instance_dict['group'][
-            'last_timestamp'] = self.report_group.last_timestamp
-        instance_dict['group'][
-            'first_timestamp'] = self.report_group.first_timestamp
-        instance_dict['group']['public'] = self.report_group.public
-        instance_dict['group']['fixed'] = self.report_group.fixed
-        instance_dict['group']['read'] = self.report_group.read
-        instance_dict['group'][
-            'average_duration'] = self.report_group.average_duration
 
-        instance_dict[
-            'resource_name'] = self.report_group.application.resource_name
-        instance_dict['report_type'] = self.report_type
-
-        if instance_dict['http_status'] == 404 and not instance_dict['error']:
-            instance_dict['error'] = '404 Not Found'
+        instance_dict = super(Report, self).get_dict()
+        instance_dict["req_stats"] = self.req_stats()
+        instance_dict["group"] = {}
+        instance_dict["group"]["id"] = self.report_group.id
+        instance_dict["group"]["total_reports"] = self.report_group.total_reports
+        instance_dict["group"]["last_report"] = self.report_group.last_report
+        instance_dict["group"]["priority"] = self.report_group.priority
+        instance_dict["group"]["occurences"] = self.report_group.occurences
+        instance_dict["group"]["last_timestamp"] = self.report_group.last_timestamp
+        instance_dict["group"]["first_timestamp"] = self.report_group.first_timestamp
+        instance_dict["group"]["public"] = self.report_group.public
+        instance_dict["group"]["fixed"] = self.report_group.fixed
+        instance_dict["group"]["read"] = self.report_group.read
+        instance_dict["group"]["average_duration"] = self.report_group.average_duration
+
+        instance_dict["resource_name"] = self.report_group.application.resource_name
+        instance_dict["report_type"] = self.report_type
+
+        if instance_dict["http_status"] == 404 and not instance_dict["error"]:
+            instance_dict["error"] = "404 Not Found"
 
         if details:
-            instance_dict['affected_users_count'] = \
-                ReportGroupService.affected_users_count(self.report_group)
-            instance_dict['top_affected_users'] = [
-                {'username': u.username, 'count': u.count} for u in
-                ReportGroupService.top_affected_users(self.report_group)]
-            instance_dict['application'] = {'integrations': []}
+            instance_dict[
+                "affected_users_count"
+            ] = ReportGroupService.affected_users_count(self.report_group)
+            instance_dict["top_affected_users"] = [
+                {"username": u.username, "count": u.count}
+                for u in ReportGroupService.top_affected_users(self.report_group)
+            ]
+            instance_dict["application"] = {"integrations": []}
             for integration in self.report_group.application.integrations:
                 if integration.front_visible:
-                    instance_dict['application']['integrations'].append(
-                        {'name': integration.integration_name,
-                         'action': integration.integration_action})
-            instance_dict['comments'] = [c.get_dict() for c in
-                                         self.report_group.comments]
-
-            instance_dict['group']['next_report'] = None
-            instance_dict['group']['previous_report'] = None
+                    instance_dict["application"]["integrations"].append(
+                        {
+                            "name": integration.integration_name,
+                            "action": integration.integration_action,
+                        }
+                    )
+            instance_dict["comments"] = [
+                c.get_dict() for c in self.report_group.comments
+            ]
+
+            instance_dict["group"]["next_report"] = None
+            instance_dict["group"]["previous_report"] = None
             next_in_group = self.get_next_in_group(request)
             previous_in_group = self.get_previous_in_group(request)
             if next_in_group:
-                instance_dict['group']['next_report'] = next_in_group
+                instance_dict["group"]["next_report"] = next_in_group
             if previous_in_group:
-                instance_dict['group']['previous_report'] = previous_in_group
+                instance_dict["group"]["previous_report"] = previous_in_group
 
             # slow call ordering
             def find_parent(row, data):
                 for r in reversed(data):
                     try:
-                        if (row['timestamp'] > r['timestamp'] and
-                                    row['end_time'] < r['end_time']):
+                        if (
+                            row["timestamp"] > r["timestamp"]
+                            and row["end_time"] < r["end_time"]
+                        ):
                             return r
                     except TypeError as e:
-                        log.warning('reports_view.find_parent: %s' % e)
+                        log.warning("reports_view.find_parent: %s" % e)
                 return None
 
             new_calls = []
@@ -274,24 +287,23 b' class Report(Base, BaseModel):'
                 for x in range(len(calls) - 1, -1, -1):
                     parent = find_parent(calls[x], calls)
                     if parent:
-                        parent['children'].append(calls[x])
+                        parent["children"].append(calls[x])
                     else:
                         # no parent at all? append to new calls anyways
                         new_calls.append(calls[x])
                         # print 'append', calls[x]
                     del calls[x]
                     break
-            instance_dict['slow_calls'] = new_calls
+            instance_dict["slow_calls"] = new_calls
 
-        instance_dict['front_url'] = self.get_public_url(request)
+        instance_dict["front_url"] = self.get_public_url(request)
 
         exclude_keys_list = exclude_keys or []
         include_keys_list = include_keys or []
         for k in list(instance_dict.keys()):
-            if k == 'group':
+            if k == "group":
                 continue
-            if (k in exclude_keys_list or
-                    (k not in include_keys_list and include_keys)):
+            if k in exclude_keys_list or (k not in include_keys_list and include_keys):
                 del instance_dict[k]
         return instance_dict
 
@@ -301,19 +313,20 b' class Report(Base, BaseModel):'
             "query": {
                 "filtered": {
                     "filter": {
-                        "and": [{"term": {"group_id": self.group_id}},
-                                {"range": {"pg_id": {"lt": self.id}}}]
+                        "and": [
+                            {"term": {"group_id": self.group_id}},
+                            {"range": {"pg_id": {"lt": self.id}}},
+                        ]
                     }
                 }
             },
-            "sort": [
-                {"_doc": {"order": "desc"}},
-            ],
+            "sort": [{"_doc": {"order": "desc"}}],
         }
-        result = request.es_conn.search(body=query, index=self.partition_id,
-                                        doc_type='report')
-        if result['hits']['total']:
-            return result['hits']['hits'][0]['_source']['pg_id']
+        result = request.es_conn.search(
+            body=query, index=self.partition_id, doc_type="report"
+        )
+        if result["hits"]["total"]:
+            return result["hits"]["hits"][0]["_source"]["pg_id"]
 
     def get_next_in_group(self, request):
         query = {
@@ -321,19 +334,20 b' class Report(Base, BaseModel):'
             "query": {
                 "filtered": {
                     "filter": {
-                        "and": [{"term": {"group_id": self.group_id}},
-                                {"range": {"pg_id": {"gt": self.id}}}]
+                        "and": [
+                            {"term": {"group_id": self.group_id}},
+                            {"range": {"pg_id": {"gt": self.id}}},
+                        ]
                     }
                 }
             },
-            "sort": [
-                {"_doc": {"order": "asc"}},
-            ],
+            "sort": [{"_doc": {"order": "asc"}}],
         }
-        result = request.es_conn.search(body=query, index=self.partition_id,
-                                        doc_type='report')
-        if result['hits']['total']:
-            return result['hits']['hits'][0]['_source']['pg_id']
+        result = request.es_conn.search(
+            body=query, index=self.partition_id, doc_type="report"
+        )
+        if result["hits"]["total"]:
+            return result["hits"]["hits"][0]["_source"]["pg_id"]
 
     def get_public_url(self, request=None, report_group=None, _app_url=None):
         """
@@ -341,53 +355,51 b' class Report(Base, BaseModel):'
         """
         if not request:
             request = get_current_request()
-        url = request.route_url('/', _app_url=_app_url)
+        url = request.route_url("/", _app_url=_app_url)
         if report_group:
-            return (url + 'ui/report/%s/%s') % (report_group.id, self.id)
-        return (url + 'ui/report/%s/%s') % (self.group_id, self.id)
+            return (url + "ui/report/%s/%s") % (report_group.id, self.id)
+        return (url + "ui/report/%s/%s") % (self.group_id, self.id)
 
     def req_stats(self):
         stats = self.request_stats.copy()
-        stats['percentages'] = {}
-        stats['percentages']['main'] = 100.0
-        main = stats.get('main', 0.0)
+        stats["percentages"] = {}
+        stats["percentages"]["main"] = 100.0
+        main = stats.get("main", 0.0)
         if not main:
             return None
         for name, call_time in stats.items():
-            if ('calls' not in name and 'main' not in name and
-                        'percentages' not in name):
-                stats['main'] -= call_time
-                stats['percentages'][name] = math.floor(
-                    (call_time / main * 100.0))
-                stats['percentages']['main'] -= stats['percentages'][name]
-        if stats['percentages']['main'] < 0.0:
-            stats['percentages']['main'] = 0.0
-            stats['main'] = 0.0
+            if "calls" not in name and "main" not in name and "percentages" not in name:
+                stats["main"] -= call_time
+                stats["percentages"][name] = math.floor((call_time / main * 100.0))
+                stats["percentages"]["main"] -= stats["percentages"][name]
+        if stats["percentages"]["main"] < 0.0:
+            stats["percentages"]["main"] = 0.0
+            stats["main"] = 0.0
         return stats
 
-    def generate_grouping_hash(self, hash_string=None, default_grouping=None,
-                               protocol_version=None):
+    def generate_grouping_hash(
+        self, hash_string=None, default_grouping=None, protocol_version=None
+    ):
         """
         Generates SHA1 hash that will be used to group reports together
         """
         if not hash_string:
-            location = self.tags.get('view_name') or self.url_path;
-            server_name = self.tags.get('server_name') or ''
-            if default_grouping == 'url_traceback':
-                hash_string = '%s_%s_%s' % (self.traceback_hash, location,
-                                            self.error)
+            location = self.tags.get("view_name") or self.url_path
+            server_name = self.tags.get("server_name") or ""
+            if default_grouping == "url_traceback":
+                hash_string = "%s_%s_%s" % (self.traceback_hash, location, self.error)
                 if self.language == Language.javascript:
-                    hash_string = '%s_%s' % (self.traceback_hash, self.error)
+                    hash_string = "%s_%s" % (self.traceback_hash, self.error)
 
-            elif default_grouping == 'traceback_server':
-                hash_string = '%s_%s' % (self.traceback_hash, server_name)
+            elif default_grouping == "traceback_server":
+                hash_string = "%s_%s" % (self.traceback_hash, server_name)
                 if self.language == Language.javascript:
-                    hash_string = '%s_%s' % (self.traceback_hash, server_name)
+                    hash_string = "%s_%s" % (self.traceback_hash, server_name)
             else:
-                hash_string = '%s_%s' % (self.error, location)
+                hash_string = "%s_%s" % (self.error, location)
         month = datetime.utcnow().date().replace(day=1)
-        hash_string = '{}_{}'.format(month, hash_string)
-        binary_string = hash_string.encode('utf8')
+        hash_string = "{}_{}".format(month, hash_string)
+        binary_string = hash_string.encode("utf8")
         self.grouping_hash = hashlib.sha1(binary_string).hexdigest()
         return self.grouping_hash
 
@@ -399,7 +411,7 b' class Report(Base, BaseModel):'
 
         if isinstance(stripped_traceback, list):
             for row in stripped_traceback:
-                row.pop('vars', None)
+                row.pop("vars", None)
         return stripped_traceback
 
     def notify_channel(self, report_group):
@@ -407,78 +419,81 b' class Report(Base, BaseModel):'
         Sends notification to websocket channel
         """
         settings = get_current_registry().settings
-        log.info('notify channelstream')
+        log.info("notify channelstream")
         if self.report_type != ReportType.error:
             return
         payload = {
-            'type': 'message',
-            "user": '__system__',
-            "channel": 'app_%s' % self.resource_id,
-            'message': {
-                'topic': 'front_dashboard.new_topic',
-                'report': {
-                    'group': {
-                        'priority': report_group.priority,
-                        'first_timestamp': report_group.first_timestamp,
-                        'last_timestamp': report_group.last_timestamp,
-                        'average_duration': report_group.average_duration,
-                        'occurences': report_group.occurences
+            "type": "message",
+            "user": "__system__",
+            "channel": "app_%s" % self.resource_id,
+            "message": {
+                "topic": "front_dashboard.new_topic",
+                "report": {
+                    "group": {
+                        "priority": report_group.priority,
+                        "first_timestamp": report_group.first_timestamp,
+                        "last_timestamp": report_group.last_timestamp,
+                        "average_duration": report_group.average_duration,
+                        "occurences": report_group.occurences,
+                    },
+                    "report_id": self.id,
+                    "group_id": self.group_id,
+                    "resource_id": self.resource_id,
+                    "http_status": self.http_status,
+                    "url_domain": self.url_domain,
+                    "url_path": self.url_path,
+                    "error": self.error or "",
+                    "server": self.tags.get("server_name"),
+                    "view_name": self.tags.get("view_name"),
+                    "front_url": self.get_public_url(),
+                },
                     },
-                    'report_id': self.id,
-                    'group_id': self.group_id,
-                    'resource_id': self.resource_id,
-                    'http_status': self.http_status,
-                    'url_domain': self.url_domain,
-                    'url_path': self.url_path,
-                    'error': self.error or '',
-                    'server': self.tags.get('server_name'),
-                    'view_name': self.tags.get('view_name'),
-                    'front_url': self.get_public_url(),
-                }
-            }
-
         }
-        channelstream_request(settings['cometd.secret'], '/message', [payload],
-                              servers=[settings['cometd_servers']])
+        channelstream_request(
+            settings["cometd.secret"],
+            "/message",
+            [payload],
+            servers=[settings["cometd_servers"]],
+        )
 
     def es_doc(self):
         tags = {}
         tag_list = []
         for name, value in self.tags.items():
-            name = name.replace('.', '_')
+            name = name.replace(".", "_")
             tag_list.append(name)
             tags[name] = {
                 "values": convert_es_type(value),
-                "numeric_values": value if (
-                    isinstance(value, (int, float)) and
-                    not isinstance(value, bool)) else None}
+                "numeric_values": value
+                if (isinstance(value, (int, float)) and not isinstance(value, bool))
+                else None,
+            }
 
-        if 'user_name' not in self.tags and self.username:
-            tags["user_name"] = {"value": [self.username],
-                                 "numeric_value": None}
+        if "user_name" not in self.tags and self.username:
+            tags["user_name"] = {"value": [self.username], "numeric_value": None}
         return {
-            '_id': str(self.id),
-            'pg_id': str(self.id),
-            'resource_id': self.resource_id,
-            'http_status': self.http_status or '',
-            'start_time': self.start_time,
-            'end_time': self.end_time,
-            'url_domain': self.url_domain if self.url_domain else '',
-            'url_path': self.url_path if self.url_path else '',
-            'duration': self.duration,
-            'error': self.error if self.error else '',
-            'report_type': self.report_type,
-            'request_id': self.request_id,
-            'ip': self.ip,
-            'group_id': str(self.group_id),
-            '_parent': str(self.group_id),
-            'tags': tags,
-            'tag_list': tag_list
+            "_id": str(self.id),
+            "pg_id": str(self.id),
+            "resource_id": self.resource_id,
+            "http_status": self.http_status or "",
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "url_domain": self.url_domain if self.url_domain else "",
+            "url_path": self.url_path if self.url_path else "",
+            "duration": self.duration,
+            "error": self.error if self.error else "",
+            "report_type": self.report_type,
+            "request_id": self.request_id,
+            "ip": self.ip,
+            "group_id": str(self.group_id),
+            "_parent": str(self.group_id),
+            "tags": tags,
+            "tag_list": tag_list,
         }
 
     @property
     def partition_id(self):
-        return 'rcae_r_%s' % self.report_group_time.strftime('%Y_%m')
+        return "rcae_r_%s" % self.report_group_time.strftime("%Y_%m")
 
     def partition_range(self):
         start_date = self.report_group_time.date().replace(day=1)
@@ -488,27 +503,31 b' class Report(Base, BaseModel):'
 
 
 def after_insert(mapper, connection, target):
-    if not hasattr(target, '_skip_ft_index'):
+    if not hasattr(target, "_skip_ft_index"):
         data = target.es_doc()
-        data.pop('_id', None)
-        Datastores.es.index(target.partition_id, 'report', data,
-                            parent=target.group_id, id=target.id)
+        data.pop("_id", None)
+        Datastores.es.index(
+            target.partition_id, "report", data, parent=target.group_id, id=target.id
+        )
 
 
 def after_update(mapper, connection, target):
-    if not hasattr(target, '_skip_ft_index'):
+    if not hasattr(target, "_skip_ft_index"):
         data = target.es_doc()
-        data.pop('_id', None)
-        Datastores.es.index(target.partition_id, 'report', data,
-                            parent=target.group_id, id=target.id)
+        data.pop("_id", None)
+        Datastores.es.index(
+            target.partition_id, "report", data, parent=target.group_id, id=target.id
+        )
 
 
 def after_delete(mapper, connection, target):
-    if not hasattr(target, '_skip_ft_index'):
-        query = {"query":{'term': {'pg_id': target.id}}}
-        Datastores.es.transport.perform_request("DELETE", '/{}/{}/_query'.format(target.partition_id, 'report'), body=query)
+    if not hasattr(target, "_skip_ft_index"):
+        query = {"query": {"term": {"pg_id": target.id}}}
+        Datastores.es.transport.perform_request(
+            "DELETE", "/{}/{}/_query".format(target.partition_id, "report"), body=query
+        )
 
 
-sa.event.listen(Report, 'after_insert', after_insert)
-sa.event.listen(Report, 'after_update', after_update)
-sa.event.listen(Report, 'after_delete', after_delete)
+sa.event.listen(Report, "after_insert", after_insert)
+sa.event.listen(Report, "after_update", after_update)
+sa.event.listen(Report, "after_delete", after_delete)

backend/src/appenlight/models/report_assignment.py

@@ -20,13 +20,16 b' import sqlalchemy as sa'
 
 
 class ReportAssignment(Base, BaseModel):
-    __tablename__ = 'reports_assignments'
+    __tablename__ = "reports_assignments"
 
-    group_id = sa.Column(sa.BigInteger,
-                         sa.ForeignKey('reports_groups.id', ondelete='cascade',
-                                       onupdate='cascade'),
-                         primary_key=True)
-    owner_id = sa.Column(sa.Integer,
-                          sa.ForeignKey('users.id', onupdate='CASCADE',
-                                        ondelete='CASCADE'), primary_key=True)
+    group_id = sa.Column(
+        sa.BigInteger,
+        sa.ForeignKey("reports_groups.id", ondelete="cascade", onupdate="cascade"),
+        primary_key=True,
+    )
+    owner_id = sa.Column(
+        sa.Integer,
+        sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE"),
+        primary_key=True,
+    )
     report_time = sa.Column(sa.DateTime(), nullable=False)

backend/src/appenlight/models/report_comment.py

@@ -22,23 +22,23 b' from ziggurat_foundations.models.base import BaseModel'
 
 
 class ReportComment(Base, BaseModel):
-    __tablename__ = 'reports_comments'
+    __tablename__ = "reports_comments"
 
     comment_id = sa.Column(sa.Integer, nullable=False, primary_key=True)
-    group_id = sa.Column(sa.BigInteger,
-                         sa.ForeignKey('reports_groups.id', ondelete='cascade',
-                                       onupdate='cascade'))
-    body = sa.Column(sa.UnicodeText(), default='')
-    owner_id = sa.Column(sa.Integer,
-                         sa.ForeignKey('users.id', onupdate='CASCADE',
-                                       ondelete='CASCADE'))
-    created_timestamp = sa.Column(sa.DateTime(),
-                                  default=datetime.utcnow,
-                                  server_default=sa.func.now())
+    group_id = sa.Column(
+        sa.BigInteger,
+        sa.ForeignKey("reports_groups.id", ondelete="cascade", onupdate="cascade"),
+    )
+    body = sa.Column(sa.UnicodeText(), default="")
+    owner_id = sa.Column(
+        sa.Integer, sa.ForeignKey("users.id", onupdate="CASCADE", ondelete="CASCADE")
+    )
+    created_timestamp = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
     report_time = sa.Column(sa.DateTime(), nullable=False)
 
-    owner = sa.orm.relationship('User',
-                                lazy='joined')
+    owner = sa.orm.relationship("User", lazy="joined")
 
     @property
     def processed_body(self):
@@ -46,5 +46,5 b' class ReportComment(Base, BaseModel):'
 
     def get_dict(self):
         instance_dict = super(ReportComment, self).get_dict()
-        instance_dict['user_name'] = self.owner.user_name
+        instance_dict["user_name"] = self.owner.user_name
         return instance_dict

backend/src/appenlight/models/report_group.py

@@ -33,26 +33,30 b' log = logging.getLogger(__name__)'
 
 
 class ReportGroup(Base, BaseModel):
-    __tablename__ = 'reports_groups'
-    __table_args__ = {'implicit_returning': False}
+    __tablename__ = "reports_groups"
+    __table_args__ = {"implicit_returning": False}
 
     id = sa.Column(sa.BigInteger(), nullable=False, primary_key=True)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('applications.resource_id',
-                                          onupdate='CASCADE',
-                                          ondelete='CASCADE'),
+    resource_id = sa.Column(
+        sa.Integer(),
+        sa.ForeignKey(
+            "applications.resource_id", onupdate="CASCADE", ondelete="CASCADE"
+        ),
                             nullable=False,
-                            index=True)
-    priority = sa.Column(sa.Integer, nullable=False, index=True, default=5,
-                         server_default='5')
-    first_timestamp = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                                server_default=sa.func.now())
-    last_timestamp = sa.Column(sa.DateTime(), default=datetime.utcnow,
-                               server_default=sa.func.now())
+        index=True,
+    )
+    priority = sa.Column(
+        sa.Integer, nullable=False, index=True, default=5, server_default="5"
+    )
+    first_timestamp = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
+    last_timestamp = sa.Column(
+        sa.DateTime(), default=datetime.utcnow, server_default=sa.func.now()
+    )
     error = sa.Column(sa.UnicodeText(), index=True)
-    grouping_hash = sa.Column(sa.String(40), default='')
-    triggered_postprocesses_ids = sa.Column(JSON(), nullable=False,
-                                            default=list)
+    grouping_hash = sa.Column(sa.String(40), default="")
+    triggered_postprocesses_ids = sa.Column(JSON(), nullable=False, default=list)
     report_type = sa.Column(sa.Integer, default=1)
     total_reports = sa.Column(sa.Integer, default=1)
     last_report = sa.Column(sa.Integer)
@@ -64,50 +68,58 b' class ReportGroup(Base, BaseModel):'
     notified = sa.Column(sa.Boolean(), index=True, default=False)
     public = sa.Column(sa.Boolean(), index=True, default=False)
 
-    reports = sa.orm.relationship('Report',
-                                  lazy='dynamic',
-                                  backref='report_group',
+    reports = sa.orm.relationship(
+        "Report",
+        lazy="dynamic",
+        backref="report_group",
                                   cascade="all, delete-orphan",
                                   passive_deletes=True,
-                                  passive_updates=True, )
+        passive_updates=True,
+    )
 
-    comments = sa.orm.relationship('ReportComment',
-                                   lazy='dynamic',
-                                   backref='report',
+    comments = sa.orm.relationship(
+        "ReportComment",
+        lazy="dynamic",
+        backref="report",
                                    cascade="all, delete-orphan",
                                    passive_deletes=True,
                                    passive_updates=True,
-                                   order_by="ReportComment.comment_id")
+        order_by="ReportComment.comment_id",
+    )
 
-    assigned_users = sa.orm.relationship('User',
+    assigned_users = sa.orm.relationship(
+        "User",
                                          backref=sa.orm.backref(
-                                             'assigned_reports_relation',
-                                             lazy='dynamic',
-                                             order_by=sa.desc(
-                                                 sa.text("reports_groups.id"))
+            "assigned_reports_relation",
+            lazy="dynamic",
+            order_by=sa.desc(sa.text("reports_groups.id")),
                                          ),
                                          passive_deletes=True,
                                          passive_updates=True,
-                                         secondary='reports_assignments',
-                                         order_by="User.user_name")
-
-    stats = sa.orm.relationship('ReportStat',
-                                lazy='dynamic',
-                                backref='report',
+        secondary="reports_assignments",
+        order_by="User.user_name",
+    )
+
+    stats = sa.orm.relationship(
+        "ReportStat",
+        lazy="dynamic",
+        backref="report",
                                 passive_deletes=True,
-                                passive_updates=True, )
+        passive_updates=True,
+    )
 
-    last_report_ref = sa.orm.relationship('Report',
+    last_report_ref = sa.orm.relationship(
+        "Report",
                                           uselist=False,
-                                          primaryjoin="ReportGroup.last_report "
-                                                      "== Report.id",
+        primaryjoin="ReportGroup.last_report " "== Report.id",
                                           foreign_keys="Report.id",
                                           cascade="all, delete-orphan",
                                           passive_deletes=True,
-                                          passive_updates=True, )
+        passive_updates=True,
+    )
 
     def __repr__(self):
-        return '<ReportGroup id:{}>'.format(self.id)
+        return "<ReportGroup id:{}>".format(self.id)
 
     def get_report(self, report_id=None, public=False):
         """
@@ -121,8 +133,8 b' class ReportGroup(Base, BaseModel):'
             return self.reports.filter(Report.id == report_id).first()
 
     def get_public_url(self, request, _app_url=None):
-        url = request.route_url('/', _app_url=_app_url)
-        return (url + 'ui/report/%s') % self.id
+        url = request.route_url("/", _app_url=_app_url)
+        return (url + "ui/report/%s") % self.id
 
     def run_postprocessing(self, report):
         """
@@ -135,12 +147,15 b' class ReportGroup(Base, BaseModel):'
             rule_obj = Rule(action.rule, REPORT_TYPE_MATRIX)
             report_dict = report.get_dict(request)
             # if was not processed yet
-            if (rule_obj.match(report_dict) and
-                        action.pkey not in self.triggered_postprocesses_ids):
+            if (
+                rule_obj.match(report_dict)
+                and action.pkey not in self.triggered_postprocesses_ids
+            ):
                 action.postprocess(self)
                 # this way sqla can track mutation of list
-                self.triggered_postprocesses_ids = \
-                    self.triggered_postprocesses_ids + [action.pkey]
+                self.triggered_postprocesses_ids = self.triggered_postprocesses_ids + [
+                    action.pkey
+                ]
 
         get_db_session(None, self).flush()
         # do not go out of bounds
@@ -151,31 +166,30 b' class ReportGroup(Base, BaseModel):'
 
     def get_dict(self, request):
         instance_dict = super(ReportGroup, self).get_dict()
-        instance_dict['server_name'] = self.get_report().tags.get(
-            'server_name')
-        instance_dict['view_name'] = self.get_report().tags.get('view_name')
-        instance_dict['resource_name'] = self.application.resource_name
-        instance_dict['report_type'] = self.get_report().report_type
-        instance_dict['url_path'] = self.get_report().url_path
-        instance_dict['front_url'] = self.get_report().get_public_url(request)
-        del instance_dict['triggered_postprocesses_ids']
+        instance_dict["server_name"] = self.get_report().tags.get("server_name")
+        instance_dict["view_name"] = self.get_report().tags.get("view_name")
+        instance_dict["resource_name"] = self.application.resource_name
+        instance_dict["report_type"] = self.get_report().report_type
+        instance_dict["url_path"] = self.get_report().url_path
+        instance_dict["front_url"] = self.get_report().get_public_url(request)
+        del instance_dict["triggered_postprocesses_ids"]
         return instance_dict
 
     def es_doc(self):
         return {
-            '_id': str(self.id),
-            'pg_id': str(self.id),
-            'resource_id': self.resource_id,
-            'error': self.error,
-            'fixed': self.fixed,
-            'public': self.public,
-            'read': self.read,
-            'priority': self.priority,
-            'occurences': self.occurences,
-            'average_duration': self.average_duration,
-            'summed_duration': self.summed_duration,
-            'first_timestamp': self.first_timestamp,
-            'last_timestamp': self.last_timestamp
+            "_id": str(self.id),
+            "pg_id": str(self.id),
+            "resource_id": self.resource_id,
+            "error": self.error,
+            "fixed": self.fixed,
+            "public": self.public,
+            "read": self.read,
+            "priority": self.priority,
+            "occurences": self.occurences,
+            "average_duration": self.average_duration,
+            "summed_duration": self.summed_duration,
+            "first_timestamp": self.first_timestamp,
+            "last_timestamp": self.last_timestamp,
         }
 
     def set_notification_info(self, notify_10=False, notify_100=False):
@@ -184,53 +198,54 b' class ReportGroup(Base, BaseModel):'
         """
         current_time = datetime.utcnow().replace(second=0, microsecond=0)
         # global app counter
-        key = REDIS_KEYS['counters']['reports_per_type'].format(
-            self.report_type, current_time)
+        key = REDIS_KEYS["counters"]["reports_per_type"].format(
+            self.report_type, current_time
+        )
         redis_pipeline = Datastores.redis.pipeline()
         redis_pipeline.incr(key)
         redis_pipeline.expire(key, 3600 * 24)
         # detailed app notification for alerts and notifications
+        redis_pipeline.sadd(REDIS_KEYS["apps_that_had_reports"], self.resource_id)
         redis_pipeline.sadd(
-            REDIS_KEYS['apps_that_had_reports'], self.resource_id)
-        redis_pipeline.sadd(
-            REDIS_KEYS['apps_that_had_reports_alerting'], self.resource_id)
+            REDIS_KEYS["apps_that_had_reports_alerting"], self.resource_id
+        )
         # only notify for exceptions here
         if self.report_type == ReportType.error:
+            redis_pipeline.sadd(REDIS_KEYS["apps_that_had_reports"], self.resource_id)
             redis_pipeline.sadd(
-                REDIS_KEYS['apps_that_had_reports'], self.resource_id)
-            redis_pipeline.sadd(
-                REDIS_KEYS['apps_that_had_error_reports_alerting'],
-                self.resource_id)
-        key = REDIS_KEYS['counters']['report_group_occurences'].format(self.id)
+                REDIS_KEYS["apps_that_had_error_reports_alerting"], self.resource_id
+            )
+        key = REDIS_KEYS["counters"]["report_group_occurences"].format(self.id)
         redis_pipeline.incr(key)
         redis_pipeline.expire(key, 3600 * 24)
-        key = REDIS_KEYS['counters']['report_group_occurences_alerting'].format(
-            self.id)
+        key = REDIS_KEYS["counters"]["report_group_occurences_alerting"].format(self.id)
         redis_pipeline.incr(key)
         redis_pipeline.expire(key, 3600 * 24)
 
         if notify_10:
-            key = REDIS_KEYS['counters'][
-                'report_group_occurences_10th'].format(self.id)
+            key = REDIS_KEYS["counters"]["report_group_occurences_10th"].format(self.id)
             redis_pipeline.setex(key, 3600 * 24, 1)
         if notify_100:
-            key = REDIS_KEYS['counters'][
-                'report_group_occurences_100th'].format(self.id)
+            key = REDIS_KEYS["counters"]["report_group_occurences_100th"].format(
+                self.id
+            )
             redis_pipeline.setex(key, 3600 * 24, 1)
 
-        key = REDIS_KEYS['reports_to_notify_per_type_per_app'].format(
-            self.report_type, self.resource_id)
+        key = REDIS_KEYS["reports_to_notify_per_type_per_app"].format(
+            self.report_type, self.resource_id
+        )
         redis_pipeline.sadd(key, self.id)
         redis_pipeline.expire(key, 3600 * 24)
-        key = REDIS_KEYS['reports_to_notify_per_type_per_app_alerting'].format(
-            self.report_type, self.resource_id)
+        key = REDIS_KEYS["reports_to_notify_per_type_per_app_alerting"].format(
+            self.report_type, self.resource_id
+        )
         redis_pipeline.sadd(key, self.id)
         redis_pipeline.expire(key, 3600 * 24)
         redis_pipeline.execute()
 
     @property
     def partition_id(self):
-        return 'rcae_r_%s' % self.first_timestamp.strftime('%Y_%m')
+        return "rcae_r_%s" % self.first_timestamp.strftime("%Y_%m")
 
     def partition_range(self):
         start_date = self.first_timestamp.date().replace(day=1)
@@ -240,29 +255,33 b' class ReportGroup(Base, BaseModel):'
 
 
 def after_insert(mapper, connection, target):
-    if not hasattr(target, '_skip_ft_index'):
+    if not hasattr(target, "_skip_ft_index"):
         data = target.es_doc()
-        data.pop('_id', None)
-        Datastores.es.index(target.partition_id, 'report_group',
-                            data, id=target.id)
+        data.pop("_id", None)
+        Datastores.es.index(target.partition_id, "report_group", data, id=target.id)
 
 
 def after_update(mapper, connection, target):
-    if not hasattr(target, '_skip_ft_index'):
+    if not hasattr(target, "_skip_ft_index"):
         data = target.es_doc()
-        data.pop('_id', None)
-        Datastores.es.index(target.partition_id, 'report_group',
-                            data, id=target.id)
+        data.pop("_id", None)
+        Datastores.es.index(target.partition_id, "report_group", data, id=target.id)
 
 
 def after_delete(mapper, connection, target):
-    query = {"query": {'term': {'group_id': target.id}}}
+    query = {"query": {"term": {"group_id": target.id}}}
     # delete by query
-    Datastores.es.transport.perform_request("DELETE", '/{}/{}/_query'.format(target.partition_id, 'report'), body=query)
-    query = {"query": {'term': {'pg_id': target.id}}}
-    Datastores.es.transport.perform_request("DELETE", '/{}/{}/_query'.format(target.partition_id, 'report_group'), body=query)
-
-
-sa.event.listen(ReportGroup, 'after_insert', after_insert)
-sa.event.listen(ReportGroup, 'after_update', after_update)
-sa.event.listen(ReportGroup, 'after_delete', after_delete)
+    Datastores.es.transport.perform_request(
+        "DELETE", "/{}/{}/_query".format(target.partition_id, "report"), body=query
+    )
+    query = {"query": {"term": {"pg_id": target.id}}}
+    Datastores.es.transport.perform_request(
+        "DELETE",
+        "/{}/{}/_query".format(target.partition_id, "report_group"),
+        body=query,
+    )
+
+
+sa.event.listen(ReportGroup, "after_insert", after_insert)
+sa.event.listen(ReportGroup, "after_update", after_update)
+sa.event.listen(ReportGroup, "after_delete", after_delete)

backend/src/appenlight/models/report_stat.py

@@ -22,53 +22,58 b' from ziggurat_foundations.models.base import BaseModel'
 
 
 class ReportStat(Base, BaseModel):
-    __tablename__ = 'reports_stats'
-    __table_args__ = {'implicit_returning': False}
+    __tablename__ = "reports_stats"
+    __table_args__ = {"implicit_returning": False}
 
-    group_id = sa.Column(sa.BigInteger(),
-                         sa.ForeignKey('reports_groups.id'),
-                         nullable=False)
-    resource_id = sa.Column(sa.Integer(),
-                            sa.ForeignKey('applications.resource_id'),
-                            nullable=False)
+    group_id = sa.Column(
+        sa.BigInteger(), sa.ForeignKey("reports_groups.id"), nullable=False
+    )
+    resource_id = sa.Column(
+        sa.Integer(), sa.ForeignKey("applications.resource_id"), nullable=False
+    )
     start_interval = sa.Column(sa.DateTime(), nullable=False)
     occurences = sa.Column(sa.Integer, nullable=True, default=0)
-    owner_user_id = sa.Column(sa.Integer(), sa.ForeignKey('users.id'),
-                              nullable=True)
+    owner_user_id = sa.Column(sa.Integer(), sa.ForeignKey("users.id"), nullable=True)
     type = sa.Column(sa.Integer, nullable=True, default=0)
     duration = sa.Column(sa.Float, nullable=True, default=0)
     id = sa.Column(sa.BigInteger, nullable=False, primary_key=True)
-    server_name = sa.Column(sa.Unicode(128), nullable=False, default='')
-    view_name = sa.Column(sa.Unicode(128), nullable=False, default='')
+    server_name = sa.Column(sa.Unicode(128), nullable=False, default="")
+    view_name = sa.Column(sa.Unicode(128), nullable=False, default="")
 
     @property
     def partition_id(self):
-        return 'rcae_r_%s' % self.start_interval.strftime('%Y_%m')
+        return "rcae_r_%s" % self.start_interval.strftime("%Y_%m")
 
     def es_doc(self):
         return {
-            'resource_id': self.resource_id,
-            'timestamp': self.start_interval,
-            'pg_id': str(self.id),
-            'permanent': True,
-            'request_id': None,
-            'log_level': 'ERROR',
-            'message': None,
-            'namespace': 'appenlight.error',
-            'tags': {
-                'duration': {'values': self.duration,
-                             'numeric_values': self.duration},
-                'occurences': {'values': self.occurences,
-                               'numeric_values': self.occurences},
-                'group_id': {'values': self.group_id,
-                             'numeric_values': self.group_id},
-                'type': {'values': ReportType.key_from_value(self.type),
-                         'numeric_values': self.type},
-                'server_name': {'values': self.server_name,
-                                'numeric_values': None},
-                'view_name': {'values': self.view_name,
-                              'numeric_values': None},
+            "resource_id": self.resource_id,
+            "timestamp": self.start_interval,
+            "pg_id": str(self.id),
+            "permanent": True,
+            "request_id": None,
+            "log_level": "ERROR",
+            "message": None,
+            "namespace": "appenlight.error",
+            "tags": {
+                "duration": {"values": self.duration, "numeric_values": self.duration},
+                "occurences": {
+                    "values": self.occurences,
+                    "numeric_values": self.occurences,
             },
-            'tag_list': ['duration', 'occurences', 'group_id', 'type',
-                         'server_name', 'view_name']
+                "group_id": {"values": self.group_id, "numeric_values": self.group_id},
+                "type": {
+                    "values": ReportType.key_from_value(self.type),
+                    "numeric_values": self.type,
+                },
+                "server_name": {"values": self.server_name, "numeric_values": None},
+                "view_name": {"values": self.view_name, "numeric_values": None},
+            },
+            "tag_list": [
+                "duration",
+                "occurences",
+                "group_id",
+                "type",
+                "server_name",
+                "view_name",
+            ],
         }

backend/src/appenlight/models/resource.py

@@ -23,11 +23,13 b' from ziggurat_foundations.models.services.resource import ResourceService'
 
 
 class Resource(ResourceMixin, Base):
-    events = sa.orm.relationship('Event',
-                                 lazy='dynamic',
-                                 backref='resource',
+    events = sa.orm.relationship(
+        "Event",
+        lazy="dynamic",
+        backref="resource",
                                  passive_deletes=True,
-                                 passive_updates=True)
+        passive_updates=True,
+    )
 
     @property
     def owner_user_name(self):
@@ -39,46 +41,56 b' class Resource(ResourceMixin, Base):'
         if self.owner_group:
             return self.owner_group.group_name
 
-    def get_dict(self, exclude_keys=None, include_keys=None,
-                 include_perms=False, include_processing_rules=False):
+    def get_dict(
+        self,
+        exclude_keys=None,
+        include_keys=None,
+        include_perms=False,
+        include_processing_rules=False,
+    ):
         result = super(Resource, self).get_dict(exclude_keys, include_keys)
-        result['possible_permissions'] = self.__possible_permissions__
+        result["possible_permissions"] = self.__possible_permissions__
         if include_perms:
-            result['current_permissions'] = self.user_permissions_list
+            result["current_permissions"] = self.user_permissions_list
         else:
-            result['current_permissions'] = []
+            result["current_permissions"] = []
         if include_processing_rules:
-            result["postprocessing_rules"] = [rule.get_dict() for rule
-                                              in self.postprocess_conf]
+            result["postprocessing_rules"] = [
+                rule.get_dict() for rule in self.postprocess_conf
+            ]
         else:
             result["postprocessing_rules"] = []
         exclude_keys_list = exclude_keys or []
         include_keys_list = include_keys or []
         d = {}
         for k in result.keys():
-            if (k not in exclude_keys_list and
-                    (k in include_keys_list or not include_keys)):
+            if k not in exclude_keys_list and (
+                k in include_keys_list or not include_keys
+            ):
                 d[k] = result[k]
-        for k in ['owner_user_name', 'owner_group_name']:
-            if (k not in exclude_keys_list and
-                    (k in include_keys_list or not include_keys)):
+        for k in ["owner_user_name", "owner_group_name"]:
+            if k not in exclude_keys_list and (
+                k in include_keys_list or not include_keys
+            ):
                 d[k] = getattr(self, k)
         return d
 
     @property
     def user_permissions_list(self):
-        return [permission_tuple_to_dict(perm) for perm in
-                ResourceService.users_for_perm(
-                    self, '__any_permission__', limit_group_permissions=True)]
+        return [
+            permission_tuple_to_dict(perm)
+            for perm in ResourceService.users_for_perm(
+                self, "__any_permission__", limit_group_permissions=True
+            )
+        ]
 
     @property
     def __acl__(self):
         acls = []
 
         if self.owner_user_id:
-            acls.extend([(Allow, self.owner_user_id, ALL_PERMISSIONS,), ])
+            acls.extend([(Allow, self.owner_user_id, ALL_PERMISSIONS)])
 
         if self.owner_group_id:
-            acls.extend([(Allow, "group:%s" % self.owner_group_id,
-                          ALL_PERMISSIONS,), ])
+            acls.extend([(Allow, "group:%s" % self.owner_group_id, ALL_PERMISSIONS)])
         return acls

backend/src/appenlight/models/services/__init__.py

@@ -13,4 +13,3 b''
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-

backend/src/appenlight/models/services/application.py

@@ -33,7 +33,6 b' log = logging.getLogger(__name__)'
 
 
 class ApplicationService(BaseService):
-
     @classmethod
     def all(cls, db_session=None):
         db_session = get_db_session(db_session)
@@ -51,9 +50,9 b' class ApplicationService(BaseService):'
     @classmethod
     def by_api_key_cached(cls, db_session=None):
         db_session = get_db_session(db_session)
-        cache_region = get_region('redis_min_1')
+        cache_region = get_region("redis_min_1")
 
-        @cache_region.cache_on_arguments('ApplicationService.by_api_key')
+        @cache_region.cache_on_arguments("ApplicationService.by_api_key")
         def cached(*args, **kwargs):
             app = cls.by_api_key(*args, db_session=db_session, **kwargs)
             if app:
@@ -63,10 +62,11 b' class ApplicationService(BaseService):'
         return cached
 
     @classmethod
-    def by_public_api_key(cls, api_key, db_session=None, from_cache=False,
-                          request=None):
+    def by_public_api_key(
+        cls, api_key, db_session=None, from_cache=False, request=None
+    ):
         db_session = get_db_session(db_session)
-        cache_region = get_region('redis_min_1')
+        cache_region = get_region("redis_min_1")
 
         def uncached(api_key):
             q = db_session.query(Application)
@@ -75,8 +75,8 b' class ApplicationService(BaseService):'
             return q.first()
 
         if from_cache:
-            @cache_region.cache_on_arguments(
-                'ApplicationService.by_public_api_key')
+
+            @cache_region.cache_on_arguments("ApplicationService.by_public_api_key")
             def cached(api_key):
                 app = uncached(api_key)
                 if app:
@@ -98,9 +98,9 b' class ApplicationService(BaseService):'
     @classmethod
     def by_id_cached(cls, db_session=None):
         db_session = get_db_session(db_session)
-        cache_region = get_region('redis_min_1')
+        cache_region = get_region("redis_min_1")
 
-        @cache_region.cache_on_arguments('ApplicationService.by_id')
+        @cache_region.cache_on_arguments("ApplicationService.by_id")
         def cached(*args, **kwargs):
             app = cls.by_id(*args, db_session=db_session, **kwargs)
             if app:
@@ -119,10 +119,9 b' class ApplicationService(BaseService):'
     @classmethod
     def by_http_referer(cls, referer_string, db_session=None):
         db_session = get_db_session(db_session)
-        domain = urllib.parse.urlsplit(
-            referer_string, allow_fragments=False).netloc
+        domain = urllib.parse.urlsplit(referer_string, allow_fragments=False).netloc
         if domain:
-            if domain.startswith('www.'):
+            if domain.startswith("www."):
                 domain = domain[4:]
         q = db_session.query(Application).filter(Application.domain == domain)
         return q.first()
@@ -132,7 +131,8 b' class ApplicationService(BaseService):'
         db_session = get_db_session(db_session)
         q = db_session.query(Application)
         q2 = ReportGroup.last_updated(
-            since_when, exclude_status=exclude_status, db_session=db_session)
+            since_when, exclude_status=exclude_status, db_session=db_session
+        )
         q2 = q2.from_self(ReportGroup.resource_id)
         q2 = q2.group_by(ReportGroup.resource_id)
         q = q.filter(Application.resource_id.in_(q2))
@@ -142,10 +142,10 b' class ApplicationService(BaseService):'
     def check_for_groups_alert(cls, resource, event_type, *args, **kwargs):
         """ Check for open alerts depending on group type.
         Create new one if nothing is found and send alerts """
-        db_session = get_db_session(kwargs.get('db_session'))
+        db_session = get_db_session(kwargs.get("db_session"))
         request = get_current_request()
-        report_groups = kwargs['report_groups']
-        occurence_dict = kwargs['occurence_dict']
+        report_groups = kwargs["report_groups"]
+        occurence_dict = kwargs["occurence_dict"]
 
         error_reports = 0
         slow_reports = 0
@@ -156,38 +156,45 b' class ApplicationService(BaseService):'
             elif group.get_report().report_type == ReportType.slow:
                 slow_reports += occurences
 
-        log_msg = 'LIMIT INFO: %s : %s error reports. %s slow_reports' % (
+        log_msg = "LIMIT INFO: %s : %s error reports. %s slow_reports" % (
             resource,
             error_reports,
-            slow_reports)
+            slow_reports,
+        )
         logging.warning(log_msg)
         threshold = 10
-        for event_type in ['error_report_alert', 'slow_report_alert']:
-            if (error_reports < resource.error_report_threshold and
-                        event_type == 'error_report_alert'):
+        for event_type in ["error_report_alert", "slow_report_alert"]:
+            if (
+                error_reports < resource.error_report_threshold
+                and event_type == "error_report_alert"
+            ):
                 continue
-            elif (slow_reports <= resource.slow_report_threshold and
-                          event_type == 'slow_report_alert'):
+            elif (
+                slow_reports <= resource.slow_report_threshold
+                and event_type == "slow_report_alert"
+            ):
                 continue
-            if event_type == 'error_report_alert':
+            if event_type == "error_report_alert":
                 amount = error_reports
                 threshold = resource.error_report_threshold
-            elif event_type == 'slow_report_alert':
+            elif event_type == "slow_report_alert":
                 amount = slow_reports
                 threshold = resource.slow_report_threshold
 
-            event = EventService.for_resource([resource.resource_id],
-                                              event_type=Event.types[
-                                                  event_type],
-                                              status=Event.statuses['active'])
+            event = EventService.for_resource(
+                [resource.resource_id],
+                event_type=Event.types[event_type],
+                status=Event.statuses["active"],
+            )
             if event.first():
-                log.info('ALERT: PROGRESS: %s %s' % (event_type, resource))
+                log.info("ALERT: PROGRESS: %s %s" % (event_type, resource))
             else:
-                log.warning('ALERT: OPEN: %s %s' % (event_type, resource))
-                new_event = Event(resource_id=resource.resource_id,
+                log.warning("ALERT: OPEN: %s %s" % (event_type, resource))
+                new_event = Event(
+                    resource_id=resource.resource_id,
                                   event_type=Event.types[event_type],
-                                  status=Event.statuses['active'],
-                                  values={'reports': amount,
-                                          'threshold': threshold})
+                    status=Event.statuses["active"],
+                    values={"reports": amount, "threshold": threshold},
+                )
                 db_session.add(new_event)
                 new_event.send_alerts(request=request, resource=resource)

backend/src/appenlight/models/services/application_postprocess_conf.py

@@ -21,7 +21,6 b' from appenlight.models.services.base import BaseService'
 
 
 class ApplicationPostprocessConfService(BaseService):
-
     @classmethod
     def by_pkey(cls, pkey, db_session=None):
         db_session = get_db_session(db_session)

backend/src/appenlight/models/services/config.py

@@ -40,9 +40,10 b' class ConfigService(BaseService):'
         if pairs:
             conditions = []
             for pair in pairs:
-                conditions.append(sa.and_(
-                    Config.key == pair['key'],
-                    Config.section == pair['section'])
+                conditions.append(
+                    sa.and_(
+                        Config.key == pair["key"], Config.section == pair["section"]
+                    )
                 )
 
             query = query.filter(sa.or_(*conditions))
@@ -57,13 +58,15 b' class ConfigService(BaseService):'
         return config
 
     @classmethod
-    def by_key_and_section(cls, key, section, auto_create=False,
-                           default_value=None, db_session=None):
+    def by_key_and_section(
+        cls, key, section, auto_create=False, default_value=None, db_session=None
+    ):
         db_session = get_db_session(db_session)
         registry = get_current_registry()
 
         @registry.cache_regions.memory_min_1.cache_on_arguments(
-            namespace='ConfigService.by_key_and_section')
+            namespace="ConfigService.by_key_and_section"
+        )
         def cached(key, section):
             query = db_session.query(Config).filter(Config.key == key)
             query = query.filter(Config.section == section)
@@ -76,8 +79,7 b' class ConfigService(BaseService):'
         if config:
             config = db_session.merge(config, load=False)
         if config is None and auto_create:
-            config = ConfigService.create_config(key, section,
-                                                 value=default_value)
+            config = ConfigService.create_config(key, section, value=default_value)
             cached.invalidate(key, section)
         return config
 
@@ -87,14 +89,28 b' class ConfigService(BaseService):'
         Will add fresh default config values to database if no keys are found
         :return:
         """
-        log.info('Checking/setting default values')
-        self.by_key_and_section('template_footer_html', 'global',
-                                default_value='', auto_create=True)
-        self.by_key_and_section('list_groups_to_non_admins', 'global',
-                                default_value=True, auto_create=True)
-        self.by_key_and_section('per_application_reports_rate_limit', 'global',
-                                default_value=2000, auto_create=True)
-        self.by_key_and_section('per_application_logs_rate_limit', 'global',
-                                default_value=100000, auto_create=True)
-        self.by_key_and_section('per_application_metrics_rate_limit', 'global',
-                                default_value=100000, auto_create=True)
+        log.info("Checking/setting default values")
+        self.by_key_and_section(
+            "template_footer_html", "global", default_value="", auto_create=True
+        )
+        self.by_key_and_section(
+            "list_groups_to_non_admins", "global", default_value=True, auto_create=True
+        )
+        self.by_key_and_section(
+            "per_application_reports_rate_limit",
+            "global",
+            default_value=2000,
+            auto_create=True,
+        )
+        self.by_key_and_section(
+            "per_application_logs_rate_limit",
+            "global",
+            default_value=100000,
+            auto_create=True,
+        )
+        self.by_key_and_section(
+            "per_application_metrics_rate_limit",
+            "global",
+            default_value=100000,
+            auto_create=True,
+        )

backend/src/appenlight/models/services/event.py

@@ -26,10 +26,19 b' from appenlight.models.services.base import BaseService'
 
 class EventService(BaseService):
     @classmethod
-    def for_resource(cls, resource_ids, event_type=None, status=None,
-                     since_when=None, limit=20, event_id=None,
-                     target_uuid=None, order_by=None, or_target_user_id=None,
-                     db_session=None):
+    def for_resource(
+        cls,
+        resource_ids,
+        event_type=None,
+        status=None,
+        since_when=None,
+        limit=20,
+        event_id=None,
+        target_uuid=None,
+        order_by=None,
+        or_target_user_id=None,
+        db_session=None,
+    ):
         """
         Fetches events including based on passed params OR if target_user_id
         is present include events that just target this user
@@ -57,8 +66,7 b' class EventService(BaseService):'
         if or_target_user_id:
             or_cond.append(sa.or_(Event.target_user_id == or_target_user_id))
 
-        query = query.filter(sa.or_(sa.and_(*and_cond),
-                                    *or_cond))
+        query = query.filter(sa.or_(sa.and_(*and_cond), *or_cond))
         if not order_by:
             query = query.order_by(sa.desc(Event.start_date))
         if limit:
@@ -67,8 +75,15 b' class EventService(BaseService):'
         return query
 
     @classmethod
-    def by_type_and_status(cls, event_types, status_types, since_when=None,
-                           older_than=None, db_session=None, app_ids=None):
+    def by_type_and_status(
+        cls,
+        event_types,
+        status_types,
+        since_when=None,
+        older_than=None,
+        db_session=None,
+        app_ids=None,
+    ):
         db_session = get_db_session(db_session)
         query = db_session.query(Event)
         query = query.filter(Event.event_type.in_(event_types))
@@ -84,26 +99,38 b' class EventService(BaseService):'
     @classmethod
     def latest_for_user(cls, user, db_session=None):
         registry = get_current_registry()
-        resources = UserService.resources_with_perms(user, ['view'], resource_types=registry.resource_types)
+        resources = UserService.resources_with_perms(
+            user, ["view"], resource_types=registry.resource_types
+        )
         resource_ids = [r.resource_id for r in resources]
         db_session = get_db_session(db_session)
         return EventService.for_resource(
-            resource_ids, or_target_user_id=user.id, limit=10,
-            db_session=db_session)
+            resource_ids, or_target_user_id=user.id, limit=10, db_session=db_session
+        )
 
     @classmethod
-    def get_paginator(cls, user, page=1, item_count=None, items_per_page=50,
-                      order_by=None, filter_settings=None, db_session=None):
+    def get_paginator(
+        cls,
+        user,
+        page=1,
+        item_count=None,
+        items_per_page=50,
+        order_by=None,
+        filter_settings=None,
+        db_session=None,
+    ):
         if not filter_settings:
             filter_settings = {}
         registry = get_current_registry()
-        resources = UserService.resources_with_perms(user, ['view'], resource_types=registry.resource_types)
+        resources = UserService.resources_with_perms(
+            user, ["view"], resource_types=registry.resource_types
+        )
         resource_ids = [r.resource_id for r in resources]
         query = EventService.for_resource(
-            resource_ids, or_target_user_id=user.id, limit=100,
-            db_session=db_session)
+            resource_ids, or_target_user_id=user.id, limit=100, db_session=db_session
+        )
 
-        paginator = SqlalchemyOrmPage(query, page=page,
-                                      items_per_page=items_per_page,
-                                      **filter_settings)
+        paginator = SqlalchemyOrmPage(
+            query, page=page, items_per_page=items_per_page, **filter_settings
+        )
         return paginator

backend/src/appenlight/models/services/group_resource_permission.py

@@ -16,18 +16,20 b''
 
 from appenlight.models.group_resource_permission import GroupResourcePermission
 from appenlight.models import get_db_session
-from ziggurat_foundations.models.services.group_resource_permission import GroupResourcePermissionService
+from ziggurat_foundations.models.services.group_resource_permission import (
+    GroupResourcePermissionService,
+)
 
 
 class GroupResourcePermissionService(GroupResourcePermissionService):
     @classmethod
-    def by_resource_group_and_perm(cls, group_id, perm_name, resource_id,
-                                   db_session=None):
+    def by_resource_group_and_perm(
+        cls, group_id, perm_name, resource_id, db_session=None
+    ):
         """ return all instances by user name, perm name and resource id """
         db_session = get_db_session(db_session)
         query = db_session.query(GroupResourcePermission)
         query = query.filter(GroupResourcePermission.group_id == group_id)
-        query = query.filter(
-            GroupResourcePermission.resource_id == resource_id)
+        query = query.filter(GroupResourcePermission.resource_id == resource_id)
         query = query.filter(GroupResourcePermission.perm_name == perm_name)
         return query.first()

backend/src/appenlight/models/services/log.py

@@ -28,8 +28,7 b' log = logging.getLogger(__name__)'
 
 class LogService(BaseService):
     @classmethod
-    def get_logs(cls, resource_ids=None, filter_settings=None,
-                 db_session=None):
+    def get_logs(cls, resource_ids=None, filter_settings=None, db_session=None):
         # ensure we always have id's passed
         if not resource_ids:
             # raise Exception('No App ID passed')
@@ -37,18 +36,17 b' class LogService(BaseService):'
         db_session = get_db_session(db_session)
         q = db_session.query(Log)
         q = q.filter(Log.resource_id.in_(resource_ids))
-        if filter_settings.get('start_date'):
-            q = q.filter(Log.timestamp >= filter_settings.get('start_date'))
-        if filter_settings.get('end_date'):
-            q = q.filter(Log.timestamp <= filter_settings.get('end_date'))
-        if filter_settings.get('log_level'):
-            q = q.filter(
-                Log.log_level == filter_settings.get('log_level').upper())
-        if filter_settings.get('request_id'):
-            request_id = filter_settings.get('request_id', '')
-            q = q.filter(Log.request_id == request_id.replace('-', ''))
-        if filter_settings.get('namespace'):
-            q = q.filter(Log.namespace == filter_settings.get('namespace'))
+        if filter_settings.get("start_date"):
+            q = q.filter(Log.timestamp >= filter_settings.get("start_date"))
+        if filter_settings.get("end_date"):
+            q = q.filter(Log.timestamp <= filter_settings.get("end_date"))
+        if filter_settings.get("log_level"):
+            q = q.filter(Log.log_level == filter_settings.get("log_level").upper())
+        if filter_settings.get("request_id"):
+            request_id = filter_settings.get("request_id", "")
+            q = q.filter(Log.request_id == request_id.replace("-", ""))
+        if filter_settings.get("namespace"):
+            q = q.filter(Log.namespace == filter_settings.get("namespace"))
         q = q.order_by(sa.desc(Log.timestamp))
         return q
 
@@ -60,20 +58,18 b' class LogService(BaseService):'
         query = {
             "query": {
                 "filtered": {
-                    "filter": {
-                        "and": [{"terms": {"resource_id": list(app_ids)}}]
-                    }
+                    "filter": {"and": [{"terms": {"resource_id": list(app_ids)}}]}
                 }
             }
         }
 
-        start_date = filter_settings.get('start_date')
-        end_date = filter_settings.get('end_date')
-        filter_part = query['query']['filtered']['filter']['and']
+        start_date = filter_settings.get("start_date")
+        end_date = filter_settings.get("end_date")
+        filter_part = query["query"]["filtered"]["filter"]["and"]
 
-        for tag in filter_settings.get('tags', []):
-            tag_values = [v.lower() for v in tag['value']]
-            key = "tags.%s.values" % tag['name'].replace('.', '_')
+        for tag in filter_settings.get("tags", []):
+            tag_values = [v.lower() for v in tag["value"]]
+            key = "tags.%s.values" % tag["name"].replace(".", "_")
             filter_part.append({"terms": {key: tag_values}})
 
         date_range = {"range": {"timestamp": {}}}
@@ -84,26 +80,21 b' class LogService(BaseService):'
         if start_date or end_date:
             filter_part.append(date_range)
 
-        levels = filter_settings.get('level')
+        levels = filter_settings.get("level")
         if levels:
-            filter_part.append({"terms": {'log_level': levels}})
-        namespaces = filter_settings.get('namespace')
+            filter_part.append({"terms": {"log_level": levels}})
+        namespaces = filter_settings.get("namespace")
         if namespaces:
-            filter_part.append({"terms": {'namespace': namespaces}})
+            filter_part.append({"terms": {"namespace": namespaces}})
 
-        request_ids = filter_settings.get('request_id')
+        request_ids = filter_settings.get("request_id")
         if request_ids:
-            filter_part.append({"terms": {'request_id': request_ids}})
+            filter_part.append({"terms": {"request_id": request_ids}})
 
-        messages = filter_settings.get('message')
+        messages = filter_settings.get("message")
         if messages:
-            query['query']['filtered']['query'] = {
-                'match': {
-                    'message': {
-                        'query': ' '.join(messages),
-                        'operator': 'and'
-                    }
-                }
+            query["query"]["filtered"]["query"] = {
+                "match": {"message": {"query": " ".join(messages), "operator": "and"}}
             }
         return query
 
@@ -118,76 +109,96 b' class LogService(BaseService):'
                     "field": "timestamp",
                     "interval": "1h",
                     "min_doc_count": 0,
-                    'extended_bounds': {
-                        'max': filter_settings.get('end_date'),
-                        'min': filter_settings.get('start_date')}
+                    "extended_bounds": {
+                        "max": filter_settings.get("end_date"),
+                        "min": filter_settings.get("start_date"),
+                    },
                 }
             }
         }
         log.debug(es_query)
-        index_names = es_index_name_limiter(filter_settings.get('start_date'),
-                                            filter_settings.get('end_date'),
-                                            ixtypes=['logs'])
+        index_names = es_index_name_limiter(
+            filter_settings.get("start_date"),
+            filter_settings.get("end_date"),
+            ixtypes=["logs"],
+        )
         if index_names:
             results = Datastores.es.search(
-                body=es_query, index=index_names, doc_type='log', size=0)
+                body=es_query, index=index_names, doc_type="log", size=0
+            )
         else:
             results = []
         return results
 
     @classmethod
-    def get_search_iterator(cls, app_ids=None, page=1, items_per_page=50,
-                            order_by=None, filter_settings=None, limit=None):
+    def get_search_iterator(
+        cls,
+        app_ids=None,
+        page=1,
+        items_per_page=50,
+        order_by=None,
+        filter_settings=None,
+        limit=None,
+    ):
         if not app_ids:
             return {}, 0
 
         es_query = cls.es_query_builder(app_ids, filter_settings)
-        sort_query = {
-            "sort": [
-                {"timestamp": {"order": "desc"}}
-            ]
-        }
+        sort_query = {"sort": [{"timestamp": {"order": "desc"}}]}
         es_query.update(sort_query)
         log.debug(es_query)
         es_from = (page - 1) * items_per_page
-        index_names = es_index_name_limiter(filter_settings.get('start_date'),
-                                            filter_settings.get('end_date'),
-                                            ixtypes=['logs'])
+        index_names = es_index_name_limiter(
+            filter_settings.get("start_date"),
+            filter_settings.get("end_date"),
+            ixtypes=["logs"],
+        )
         if not index_names:
             return {}, 0
 
-        results = Datastores.es.search(body=es_query, index=index_names,
-                                       doc_type='log', size=items_per_page,
-                                       from_=es_from)
-        if results['hits']['total'] > 5000:
+        results = Datastores.es.search(
+            body=es_query,
+            index=index_names,
+            doc_type="log",
+            size=items_per_page,
+            from_=es_from,
+        )
+        if results["hits"]["total"] > 5000:
             count = 5000
         else:
-            count = results['hits']['total']
-        return results['hits'], count
+            count = results["hits"]["total"]
+        return results["hits"], count
 
     @classmethod
-    def get_paginator_by_app_ids(cls, app_ids=None, page=1, item_count=None,
-                                 items_per_page=50, order_by=None,
+    def get_paginator_by_app_ids(
+        cls,
+        app_ids=None,
+        page=1,
+        item_count=None,
+        items_per_page=50,
+        order_by=None,
                                  filter_settings=None,
-                                 exclude_columns=None, db_session=None):
+        exclude_columns=None,
+        db_session=None,
+    ):
         if not filter_settings:
             filter_settings = {}
-        results, item_count = cls.get_search_iterator(app_ids, page,
-                                                      items_per_page, order_by,
-                                                      filter_settings)
-        paginator = paginate.Page([],
-                                  item_count=item_count,
-                                  items_per_page=items_per_page,
-                                  **filter_settings)
-        ordered_ids = tuple(item['_source']['pg_id']
-                            for item in results.get('hits', []))
+        results, item_count = cls.get_search_iterator(
+            app_ids, page, items_per_page, order_by, filter_settings
+        )
+        paginator = paginate.Page(
+            [], item_count=item_count, items_per_page=items_per_page, **filter_settings
+        )
+        ordered_ids = tuple(
+            item["_source"]["pg_id"] for item in results.get("hits", [])
+        )
 
         sorted_instance_list = []
         if ordered_ids:
             db_session = get_db_session(db_session)
             query = db_session.query(Log)
             query = query.filter(Log.log_id.in_(ordered_ids))
-            query = query.order_by(sa.desc('timestamp'))
+            query = query.order_by(sa.desc("timestamp"))
             sa_items = query.all()
             # resort by score
             for i_id in ordered_ids:
@@ -198,14 +209,14 b' class LogService(BaseService):'
         return paginator
 
     @classmethod
-    def query_by_primary_key_and_namespace(cls, list_of_pairs,
-                                           db_session=None):
+    def query_by_primary_key_and_namespace(cls, list_of_pairs, db_session=None):
         db_session = get_db_session(db_session)
         list_of_conditions = []
         query = db_session.query(Log)
         for pair in list_of_pairs:
-            list_of_conditions.append(sa.and_(
-                Log.primary_key == pair['pk'], Log.namespace == pair['ns']))
+            list_of_conditions.append(
+                sa.and_(Log.primary_key == pair["pk"], Log.namespace == pair["ns"])
+            )
         query = query.filter(sa.or_(*list_of_conditions))
         query = query.order_by(sa.asc(Log.timestamp), sa.asc(Log.log_id))
         return query

backend/src/appenlight/models/services/plugin_config.py

@@ -38,8 +38,9 b' class PluginConfigService(BaseService):'
         return query.first()
 
     @classmethod
-    def by_query(cls, resource_id=None, plugin_name=None,
-                 section=None, db_session=None):
+    def by_query(
+        cls, resource_id=None, plugin_name=None, section=None, db_session=None
+    ):
         db_session = get_db_session(db_session)
 
         query = db_session.query(PluginConfig)

backend/src/appenlight/models/services/report.py

@@ -37,21 +37,24 b' class ReportService(BaseService):'
         return q
 
     @classmethod
-    def generate_stat_rows(cls, report, resource, report_group, occurences=1,
-                           db_session=None):
+    def generate_stat_rows(
+        cls, report, resource, report_group, occurences=1, db_session=None
+    ):
         """
         Generates timeseries for this report's group
         """
         db_session = get_db_session(db_session)
-        stats = ReportStat(resource_id=report.resource_id,
+        stats = ReportStat(
+            resource_id=report.resource_id,
                            group_id=report_group.id,
                            start_interval=report.start_time,
                            owner_user_id=resource.owner_user_id,
-                           server_name=report.tags.get('server_name'),
-                           view_name=report.tags.get('view_name'),
+            server_name=report.tags.get("server_name"),
+            view_name=report.tags.get("view_name"),
                            type=report.report_type,
                            occurences=occurences,
-                           duration=report.duration)
+            duration=report.duration,
+        )
         db_session.add(stats)
         db_session.flush()
         return stats