bump requirements

backend/requirements.txt

@@ -1,49 +1,47 b''
-repoze.sendmail==4.1
+repoze.sendmail==4.4.1
 pyramid==1.10.2
-pyramid_tm==0.12
+pyramid_tm==2.2.1
 pyramid_debugtoolbar
 pyramid_authstack==1.0.1
-SQLAlchemy==1.0.12
+SQLAlchemy==1.2.18
 alembic==1.0.8
 webhelpers2==2.0
-transaction==1.4.3
-zope.sqlalchemy==0.7.6
-pyramid_mailer==0.14.1
-redis==2.10.5
+transaction==2.4.0
+zope.sqlalchemy==1.1
+pyramid_mailer==0.15.1
+redis==3.2.1
 redlock-py==1.0.8
-pyramid_jinja2==2.6.2
-psycopg2==2.7.7
-wtforms==2.1
-celery==3.1.23
-formencode==1.3.0
-psutil==2.1.2
+pyramid_jinja2==2.8
+psycopg2-binary==2.7.7
+wtforms==2.2.1
+celery==4.2.1
+formencode==1.3.1
+psutil==5.6.1
 ziggurat_foundations==0.8.3
 bcrypt==3.1.6
 appenlight_client
-markdown==2.5
+markdown==3.0.1
 colander==1.7
 defusedxml==0.5.0
-dogpile.cache==0.5.7
+dogpile.cache==0.7.1
 pyramid_redis_sessions==1.0.1
-simplejson==3.8.2
-waitress==1.0
+simplejson==3.16.0
+waitress==1.2.1
 gunicorn==19.9.0
-requests==2.20.0
-requests_oauthlib==0.6.1
-gevent==1.1.1
-gevent-websocket==0.9.5
-pygments==2.1.3
+uwsgi==2.0.18
+requests==2.21.0
+requests_oauthlib==1.2.0
+gevent==1.4.0
+pygments==2.3.1
 lxml==4.3.2
-paginate==0.5.4
-paginate-sqlalchemy==0.2.0
+paginate==0.5.6
+paginate-sqlalchemy==0.3.0
 elasticsearch>=2.0.0,<3.0.0
-six>=1.10.0
 mock==1.0.1
 itsdangerous==1.1.0
 camplight==0.9.6
 jira==1.0.7
 python-dateutil==2.5.3
 authomatic==0.1.0.post1
 cryptography==2.6.1
-webassets==0.11.1
 

backend/src/appenlight/celery/__init__.py

@@ -1,171 +1,171 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import logging
 
 from datetime import timedelta
 from celery import Celery
 from celery.bin import Option
 from celery.schedules import crontab
 from celery.signals import worker_init, task_revoked, user_preload_options
 from celery.signals import task_prerun, task_retry, task_failure, task_success
 from kombu.serialization import register
 from pyramid.paster import bootstrap
 from pyramid.request import Request
 from pyramid.scripting import prepare
 from pyramid.settings import asbool
 from pyramid.threadlocal import get_current_request
 
 from appenlight.celery.encoders import json_dumps, json_loads
 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')
 
 celery = Celery()
 
 celery.user_options['preload'].add(
     Option('--ini', dest='ini', default=None,
            help='Specifies pyramid configuration file location.')
 )
 
 
 @user_preload_options.connect
 def on_preload_parsed(options, **kwargs):
     """
     This actually configures celery from pyramid config file
     """
     celery.conf['INI_PYRAMID'] = options['ini']
     import appenlight_client.client as e_client
     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')
-    env = bootstrap(ini_location)
+    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})
     if tr_config:
         CONFIG['appenlight.transport_config'] = tr_config
     APPENLIGHT_CLIENT = e_client.Client(CONFIG)
     # log.addHandler(APPENLIGHT_CLIENT.log_handler)
     register_signals(APPENLIGHT_CLIENT)
     celery.pyramid = env
 
 
 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)
         },
         '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']
 
     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']['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
 
     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
     celery.config_from_object(celery_config)
 
 
 @task_prerun.connect
 def task_prerun_signal(task_id, task, args, kwargs, **kwaargs):
     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)
         # 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']
     get_current_request().tm.begin()
 
 
 @task_success.connect
 def task_success_signal(result, **kwargs):
     get_current_request().tm.commit()
     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'):
         celery.pyramid["closer"]()
 
 
 @task_failure.connect
 def task_failure_signal(task_id, exception, args, kwargs, traceback, einfo,
                         **kwaargs):
     get_current_request().tm.abort()
     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'):
         celery.pyramid["closer"]()

backend/src/appenlight/lib/cache_regions.py

@@ -1,183 +1,184 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import copy
 import hashlib
 import inspect
 
-from dogpile.cache import make_region, compat
+from dogpile.cache import make_region
+from dogpile.cache.util import compat
 
 regions = None
 
 
 def key_mangler(key):
     return "appenlight:dogpile:{}".format(key)
 
 
 def hashgen(namespace, fn, to_str=compat.string_type):
     """Return a function that generates a string
     key, based on a given function as well as
     arguments to the returned function itself.
 
     This is used by :meth:`.CacheRegion.cache_on_arguments`
     to generate a cache key from a decorated function.
 
     It can be replaced using the ``function_key_generator``
     argument passed to :func:`.make_region`.
 
     """
 
     if namespace is None:
         namespace = '%s:%s' % (fn.__module__, fn.__name__)
     else:
         namespace = '%s:%s|%s' % (fn.__module__, fn.__name__, namespace)
 
     args = inspect.getargspec(fn)
     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.")
         if has_self:
             args = args[1:]
 
         return namespace + "|" + hashlib.sha1(
             " ".join(map(to_str, args)).encode('utf8')).hexdigest()
 
     return generate_key
 
 
 class CacheRegions(object):
     def __init__(self, settings):
         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))
         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))
 
         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))
 
         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))
 
         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))
 
         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))
 
         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))
 
         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))
 
         self.redis_day_7 = make_region(
             function_key_generator=hashgen,
             key_mangler=key_mangler).configure(
             "dogpile.cache.redis",
             expiration_time=86400 * 7,
             **copy.deepcopy(config_redis))
 
         self.redis_day_30 = make_region(
             function_key_generator=hashgen,
             key_mangler=key_mangler).configure(
             "dogpile.cache.redis",
             expiration_time=86400 * 30,
             **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))
 
         self.memory_sec_1 = make_region(
             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)
 
         self.memory_min_1 = make_region(
             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)
 
         self.memory_min_10 = make_region(
             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)
 
 
 def get_region(region):
     return getattr(regions, region)

backend/src/appenlight/models/config.py

@@ -1,32 +1,32 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import sqlalchemy as sa
 from ziggurat_foundations.models.base import BaseModel
-from sqlalchemy.dialects.postgres import JSON
+from sqlalchemy.dialects.postgresql import JSON
 
 from . import Base
 
 
 class Config(Base, BaseModel):
     __tablename__ = 'config'
 
     key = sa.Column(sa.Unicode, primary_key=True)
     section = sa.Column(sa.Unicode, primary_key=True)
     value = sa.Column(JSON, nullable=False)
 
     def __json__(self, request):
         return self.get_dict()

backend/src/appenlight/models/plugin_config.py

@@ -1,40 +1,40 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import sqlalchemy as sa
 from ziggurat_foundations.models.base import BaseModel
-from sqlalchemy.dialects.postgres import JSON
+from sqlalchemy.dialects.postgresql import JSON
 
 from . import Base
 
 
 class PluginConfig(Base, BaseModel):
     __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'))
 
     def __json__(self, request):
         return self.get_dict()

backend/src/appenlight/models/report_group.py

@@ -1,268 +1,268 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import logging
 import sqlalchemy as sa
 
 from datetime import datetime, timedelta
 
 from pyramid.threadlocal import get_current_request
 from sqlalchemy.dialects.postgresql import JSON
 from ziggurat_foundations.models.base import BaseModel
 
 from appenlight.models import Base, get_db_session, Datastores
 from appenlight.lib.enums import ReportType
 from appenlight.lib.rule import Rule
 from appenlight.lib.redis_keys import REDIS_KEYS
 from appenlight.models.report import REPORT_TYPE_MATRIX
 
 log = logging.getLogger(__name__)
 
 
 class ReportGroup(Base, BaseModel):
     __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'),
                             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())
     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)
     report_type = sa.Column(sa.Integer, default=1)
     total_reports = sa.Column(sa.Integer, default=1)
     last_report = sa.Column(sa.Integer)
     occurences = sa.Column(sa.Integer, default=1)
     average_duration = sa.Column(sa.Float, default=0)
     summed_duration = sa.Column(sa.Float, default=0)
     read = sa.Column(sa.Boolean(), index=True, default=False)
     fixed = sa.Column(sa.Boolean(), index=True, default=False)
     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',
                                   cascade="all, delete-orphan",
                                   passive_deletes=True,
                                   passive_updates=True, )
 
     comments = sa.orm.relationship('ReportComment',
                                    lazy='dynamic',
                                    backref='report',
                                    cascade="all, delete-orphan",
                                    passive_deletes=True,
                                    passive_updates=True,
                                    order_by="ReportComment.comment_id")
 
     assigned_users = sa.orm.relationship('User',
                                          backref=sa.orm.backref(
                                              'assigned_reports_relation',
                                              lazy='dynamic',
                                              order_by=sa.desc(
-                                                 "reports_groups.id")
+                                                 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',
                                 passive_deletes=True,
                                 passive_updates=True, )
 
     last_report_ref = sa.orm.relationship('Report',
                                           uselist=False,
                                           primaryjoin="ReportGroup.last_report "
                                                       "== Report.id",
                                           foreign_keys="Report.id",
                                           cascade="all, delete-orphan",
                                           passive_deletes=True,
                                           passive_updates=True, )
 
     def __repr__(self):
         return '<ReportGroup id:{}>'.format(self.id)
 
     def get_report(self, report_id=None, public=False):
         """
         Gets report with specific id or latest report if id was not specified
         """
         from .report import Report
 
         if not report_id:
             return self.last_report_ref
         else:
             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
 
     def run_postprocessing(self, report):
         """
         Alters report group priority based on postprocessing configuration
         """
         request = get_current_request()
         get_db_session(None, self).flush()
         for action in self.application.postprocess_conf:
             get_db_session(None, self).flush()
             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):
                 action.postprocess(self)
                 # this way sqla can track mutation of list
                 self.triggered_postprocesses_ids = \
                     self.triggered_postprocesses_ids + [action.pkey]
 
         get_db_session(None, self).flush()
         # do not go out of bounds
         if self.priority < 1:
             self.priority = 1
         if self.priority > 10:
             self.priority = 10
 
     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']
         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
         }
 
     def set_notification_info(self, notify_10=False, notify_100=False):
         """
         Update redis notification maps for notification job
         """
         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)
         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_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_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)
         redis_pipeline.incr(key)
         redis_pipeline.expire(key, 3600 * 24)
 
         if notify_10:
             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)
             redis_pipeline.setex(key, 3600 * 24, 1)
 
         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)
         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')
 
     def partition_range(self):
         start_date = self.first_timestamp.date().replace(day=1)
         end_date = start_date + timedelta(days=40)
         end_date = end_date.replace(day=1)
         return start_date, end_date
 
 
 def after_insert(mapper, connection, target):
     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)
 
 
 def after_update(mapper, connection, target):
     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)
 
 
 def after_delete(mapper, connection, target):
     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)

backend/src/appenlight/models/tag.py

@@ -1,37 +1,37 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import sqlalchemy as sa
 from datetime import datetime
 from ziggurat_foundations.models.base import BaseModel
-from sqlalchemy.dialects.postgres import JSON
+from sqlalchemy.dialects.postgresql import JSON
 
 from . import Base
 
 
 class Tag(Base, BaseModel):
     __tablename__ = 'tags'
 
     id = sa.Column(sa.Integer, primary_key=True)
     resource_id = sa.Column(sa.Integer,
                             sa.ForeignKey('resources.resource_id'))
     name = sa.Column(sa.Unicode(512), nullable=False)
     value = sa.Column(JSON, nullable=False)
     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())
     times_seen = sa.Column(sa.Integer, nullable=False, default=0)

backend/src/appenlight/views/admin/admin.py

@@ -1,193 +1,192 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import logging
 import os
 import pkg_resources
 
 from datetime import datetime, timedelta
 
 import psutil
 import redis
 
 from pyramid.view import view_config
 from appenlight.models import DBSession
 from appenlight.models import Datastores
 from appenlight.lib.redis_keys import REDIS_KEYS
 
 
 def bytes2human(total):
     giga = 1024.0 ** 3
     mega = 1024.0 ** 2
     kilo = 1024.0
     if giga <= total:
         return '{:0.1f}G'.format(total / giga)
     elif mega <= total:
         return '{:0.1f}M'.format(total / mega)
     else:
         return '{:0.1f}K'.format(total / kilo)
 
 
 log = logging.getLogger(__name__)
 
 
 @view_config(route_name='section_view',
              match_param=['section=admin_section', 'view=system'],
              renderer='json', permission='root_administration')
 def system(request):
     current_time = datetime.utcnow(). \
                        replace(second=0, microsecond=0) - timedelta(minutes=1)
     # global app counter
     processed_reports = request.registry.redis_conn.get(
         REDIS_KEYS['counters']['reports_per_minute'].format(current_time))
     processed_reports = int(processed_reports) if processed_reports else 0
     processed_logs = request.registry.redis_conn.get(
         REDIS_KEYS['counters']['logs_per_minute'].format(current_time))
     processed_logs = int(processed_logs) if processed_logs else 0
     processed_metrics = request.registry.redis_conn.get(
         REDIS_KEYS['counters']['metrics_per_minute'].format(current_time))
     processed_metrics = int(processed_metrics) if processed_metrics else 0
 
     waiting_reports = 0
     waiting_logs = 0
     waiting_metrics = 0
     waiting_other = 0
 
     if 'redis' in request.registry.settings['celery.broker_type']:
         redis_client = redis.StrictRedis.from_url(
             request.registry.settings['celery.broker_url'])
         waiting_reports = redis_client.llen('reports')
         waiting_logs = redis_client.llen('logs')
         waiting_metrics = redis_client.llen('metrics')
         waiting_other = redis_client.llen('default')
 
     # process
     def replace_inf(val):
         return val if val != psutil.RLIM_INFINITY else 'unlimited'
 
     p = psutil.Process()
     fd = p.rlimit(psutil.RLIMIT_NOFILE)
     memlock = p.rlimit(psutil.RLIMIT_MEMLOCK)
     self_info = {
         'fds': {'soft': replace_inf(fd[0]),
                 'hard': replace_inf(fd[1])},
         'memlock': {'soft': replace_inf(memlock[0]),
                     'hard': replace_inf(memlock[1])},
     }
 
     # disks
     disks = []
     for part in psutil.disk_partitions(all=False):
         if os.name == 'nt':
             if 'cdrom' in part.opts or part.fstype == '':
                 continue
         usage = psutil.disk_usage(part.mountpoint)
         disks.append({
             'device': part.device,
             'total': bytes2human(usage.total),
             'used': bytes2human(usage.used),
             'free': bytes2human(usage.free),
             'percentage': int(usage.percent),
             'mountpoint': part.mountpoint,
             'fstype': part.fstype
         })
 
     # memory
     memory_v = psutil.virtual_memory()
     memory_s = psutil.swap_memory()
 
     memory = {
         'total': bytes2human(memory_v.total),
         'available': bytes2human(memory_v.available),
         'percentage': memory_v.percent,
         'used': bytes2human(memory_v.used),
         'free': bytes2human(memory_v.free),
         'active': bytes2human(memory_v.active),
         'inactive': bytes2human(memory_v.inactive),
         'buffers': bytes2human(memory_v.buffers),
         'cached': bytes2human(memory_v.cached),
         'swap_total': bytes2human(memory_s.total),
         'swap_used': bytes2human(memory_s.used)
     }
 
     # load
     system_load = os.getloadavg()
 
     # processes
     min_mem = 1024 * 1024 * 40  # 40MB
     process_info = []
     for p in psutil.process_iter():
-        mem_used = p.get_memory_info().rss
+        mem_used = p.memory_info().rss
         if mem_used < min_mem:
             continue
         process_info.append({'owner': p.username(),
                              'pid': p.pid,
-                             'cpu': round(p.get_cpu_percent(interval=0), 1),
-                             'mem_percentage': round(p.get_memory_percent(),
-                                                     1),
+                             'cpu': round(p.cpu_percent(interval=0), 1),
+                             'mem_percentage': round(p.memory_percent(),1),
                              'mem_usage': bytes2human(mem_used),
                              'name': p.name(),
                              'command': ' '.join(p.cmdline())
                              })
     process_info = sorted(process_info, key=lambda x: x['mem_percentage'],
                           reverse=True)
 
     # pg tables
 
     db_size_query = '''
     SELECT tablename, pg_total_relation_size(tablename::text) size
     FROM pg_tables WHERE tablename NOT LIKE 'pg_%' AND 
     tablename NOT LIKE 'sql_%' ORDER BY size DESC;'''
 
     db_tables = []
     for row in DBSession.execute(db_size_query):
         db_tables.append({"size_human": bytes2human(row.size),
                           "table_name": row.tablename})
 
     # es indices
     es_indices = []
     result = Datastores.es.indices.stats(metric=['store, docs'])
     for ix, stats in result['indices'].items():
         size = stats['primaries']['store']['size_in_bytes']
         es_indices.append({'name': ix,
                            'size': size,
                            'size_human': bytes2human(size)})
 
     # packages
 
     packages = ({'name': p.project_name, 'version': p.version}
                 for p in pkg_resources.working_set)
 
     return {'db_tables': db_tables,
             'es_indices': sorted(es_indices,
                                  key=lambda x: x['size'], reverse=True),
             'process_info': process_info,
             'system_load': system_load,
             'disks': disks,
             'memory': memory,
             'packages': sorted(packages, key=lambda x: x['name'].lower()),
             'current_time': current_time,
             'queue_stats': {
                 'processed_reports': processed_reports,
                 'processed_logs': processed_logs,
                 'processed_metrics': processed_metrics,
                 'waiting_reports': waiting_reports,
                 'waiting_logs': waiting_logs,
                 'waiting_metrics': waiting_metrics,
                 'waiting_other': waiting_other
             },
             'self_info': self_info
             }

backend/src/appenlight/views/applications.py

@@ -1,760 +1,759 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import copy
 import json
 import logging
-import six
 
 from datetime import datetime, timedelta
 
 import colander
 from pyramid.httpexceptions import HTTPFound, HTTPUnprocessableEntity
 from pyramid.view import view_config
 from webob.multidict import MultiDict
 from zope.sqlalchemy import mark_changed
 from ziggurat_foundations.permissions import ANY_PERMISSION
 
 import appenlight.forms as forms
 from appenlight.models import DBSession
 from appenlight.models.resource import Resource
 from appenlight.models.application import Application
 from appenlight.models.application_postprocess_conf import \
     ApplicationPostprocessConf
 from ziggurat_foundations.models.services.user import UserService
 from ziggurat_foundations.models.services.resource import ResourceService
 from ziggurat_foundations.models.services.user_resource_permission import UserResourcePermissionService
 from appenlight.models.user_resource_permission import UserResourcePermission
 from appenlight.models.group_resource_permission import GroupResourcePermission
 from appenlight.models.services.application import ApplicationService
 from appenlight.models.services.application_postprocess_conf import \
     ApplicationPostprocessConfService
 from appenlight.models.services.group import GroupService
 from appenlight.models.services.group_resource_permission import \
     GroupResourcePermissionService
 from appenlight.models.services.request_metric import RequestMetricService
 from appenlight.models.services.report_group import ReportGroupService
 from appenlight.models.services.slow_call import SlowCallService
 from appenlight.lib import helpers as h
 from appenlight.lib.utils import build_filter_settings_from_query_dict
 from appenlight.security import RootFactory
 from appenlight.models.report import REPORT_TYPE_MATRIX
 from appenlight.validators import build_rule_schema
 
 _ = str
 
 log = logging.getLogger(__name__)
 
 
 def app_not_found(request, id):
     """
     Redirects on non found and sets a flash message
     """
     request.session.flash(_('Application not found'), 'warning')
     return HTTPFound(
         location=request.route_url('applications', action='index'))
 
 
 @view_config(route_name='applications_no_id',
              renderer='json', request_method="GET", permission='authenticated')
 def applications_list(request):
     """
     Applications list
 
     if query params contain ?type=foo, it will list applications
     with one of those permissions for user,
     otherwise only list of owned applications will
     be returned
 
     appending ?root_list while being administration will allow to list all
     applications in the system
 
     """
     is_root = request.has_permission('root_administration',
                                      RootFactory(request))
     if is_root and request.GET.get('root_list'):
         resources = Resource.all().order_by(Resource.resource_name)
         resource_type = request.GET.get('resource_type', 'application')
         if resource_type:
             resources = resources.filter(
                 Resource.resource_type == resource_type)
     else:
         permissions = request.params.getall('permission')
         if permissions:
             resources = UserService.resources_with_perms(
                 request.user,
                 permissions,
                 resource_types=[request.GET.get('resource_type',
                                                 'application')])
         else:
             resources = request.user.resources.filter(
                 Application.resource_type == request.GET.get(
                     'resource_type',
                     'application'))
     return [r.get_dict(include_keys=['resource_id', 'resource_name', 'domains',
                                      'owner_user_name', 'owner_group_name'])
             for
             r in resources]
 
 
 @view_config(route_name='applications', renderer='json',
              request_method="GET", permission='view')
 def application_GET(request):
     resource = request.context.resource
     include_sensitive_info = False
     if request.has_permission('edit'):
         include_sensitive_info = True
     resource_dict = resource.get_dict(
         include_perms=include_sensitive_info,
         include_processing_rules=include_sensitive_info)
     return resource_dict
 
 
 @view_config(route_name='applications_no_id', request_method="POST",
              renderer='json', permission='create_resources')
 def application_create(request):
     """
     Creates new application instances
     """
     user = request.user
     form = forms.ApplicationCreateForm(MultiDict(request.unsafe_json_body),
                                        csrf_context=request)
     if form.validate():
         session = DBSession()
         resource = Application()
         DBSession.add(resource)
         form.populate_obj(resource)
         resource.api_key = resource.generate_api_key()
         user.resources.append(resource)
         request.session.flash(_('Application created'))
         DBSession.flush()
         mark_changed(session)
     else:
         return HTTPUnprocessableEntity(body=form.errors_json)
 
     return resource.get_dict()
 
 
 @view_config(route_name='applications', request_method="PATCH",
              renderer='json', permission='edit')
 def application_update(request):
     """
     Updates main application configuration
     """
     resource = request.context.resource
     if not resource:
         return app_not_found()
 
     # disallow setting permanent storage by non-admins
     # use default/non-resource based context for this check
     req_dict = copy.copy(request.unsafe_json_body)
     if not request.has_permission('root_administration', RootFactory(request)):
         req_dict['allow_permanent_storage'] = ''
     if not req_dict.get('uptime_url'):
         # needed cause validator is still triggered by default
         req_dict.pop('uptime_url', '')
     application_form = forms.ApplicationUpdateForm(MultiDict(req_dict),
                                                    csrf_context=request)
     if application_form.validate():
         application_form.populate_obj(resource)
         request.session.flash(_('Application updated'))
     else:
         return HTTPUnprocessableEntity(body=application_form.errors_json)
 
     include_sensitive_info = False
     if request.has_permission('edit'):
         include_sensitive_info = True
     resource_dict = resource.get_dict(
         include_perms=include_sensitive_info,
         include_processing_rules=include_sensitive_info)
     return resource_dict
 
 
 @view_config(route_name='applications_property', match_param='key=api_key',
              request_method="POST", renderer='json',
              permission='delete')
 def application_regenerate_key(request):
     """
     Regenerates API keys for application
     """
     resource = request.context.resource
 
     form = forms.CheckPasswordForm(MultiDict(request.unsafe_json_body),
                                    csrf_context=request)
     form.password.user = request.user
 
     if form.validate():
         resource.api_key = resource.generate_api_key()
         resource.public_key = resource.generate_api_key()
         msg = 'API keys regenerated - please update your application config.'
         request.session.flash(_(msg))
     else:
         return HTTPUnprocessableEntity(body=form.errors_json)
 
     if request.has_permission('edit'):
         include_sensitive_info = True
     resource_dict = resource.get_dict(
         include_perms=include_sensitive_info,
         include_processing_rules=include_sensitive_info)
     return resource_dict
 
 
 @view_config(route_name='applications_property',
              match_param='key=delete_resource',
              request_method="PATCH", renderer='json', permission='delete')
 def application_remove(request):
     """
     Removes application resources
     """
     resource = request.context.resource
     # we need polymorphic object here, to properly launch sqlalchemy events
     resource = ApplicationService.by_id(resource.resource_id)
     form = forms.CheckPasswordForm(MultiDict(request.safe_json_body or {}),
                                    csrf_context=request)
     form.password.user = request.user
     if form.validate():
         DBSession.delete(resource)
         request.session.flash(_('Application removed'))
     else:
         return HTTPUnprocessableEntity(body=form.errors_json)
 
     return True
 
 
 @view_config(route_name='applications_property', match_param='key=owner',
              request_method="PATCH", renderer='json', permission='delete')
 def application_ownership_transfer(request):
     """
     Allows application owner to transfer application ownership to other user
     """
     resource = request.context.resource
     form = forms.ChangeApplicationOwnerForm(
         MultiDict(request.safe_json_body or {}), csrf_context=request)
     form.password.user = request.user
     if form.validate():
         user = UserService.by_user_name(form.user_name.data)
         user.resources.append(resource)
         # remove integrations to not leak security data of external applications
         for integration in resource.integrations[:]:
             resource.integrations.remove(integration)
         request.session.flash(_('Application transfered'))
     else:
         return HTTPUnprocessableEntity(body=form.errors_json)
     return True
 
 
 @view_config(route_name='applications_property',
              match_param='key=postprocessing_rules', renderer='json',
              request_method='POST', permission='edit')
 def applications_postprocess_POST(request):
     """
     Creates new postprocessing rules for applications
     """
     resource = request.context.resource
     conf = ApplicationPostprocessConf()
     conf.do = 'postprocess'
     conf.new_value = '1'
     resource.postprocess_conf.append(conf)
     DBSession.flush()
     return conf.get_dict()
 
 
 @view_config(route_name='applications_property',
              match_param='key=postprocessing_rules', renderer='json',
              request_method='PATCH', permission='edit')
 def applications_postprocess_PATCH(request):
     """
     Creates new postprocessing rules for applications
     """
     json_body = request.unsafe_json_body
 
     schema = build_rule_schema(json_body['rule'], REPORT_TYPE_MATRIX)
     try:
         schema.deserialize(json_body['rule'])
     except colander.Invalid as exc:
         return HTTPUnprocessableEntity(body=json.dumps(exc.asdict()))
 
     resource = request.context.resource
     conf = ApplicationPostprocessConfService.by_pkey_and_resource_id(
         json_body['pkey'], resource.resource_id)
     conf.rule = request.unsafe_json_body['rule']
     # for now hardcode int since we dont support anything else so far
     conf.new_value = int(request.unsafe_json_body['new_value'])
     return conf.get_dict()
 
 
 @view_config(route_name='applications_property',
              match_param='key=postprocessing_rules', renderer='json',
              request_method='DELETE', permission='edit')
 def applications_postprocess_DELETE(request):
     """
     Removes application postprocessing rules
     """
     form = forms.ReactorForm(request.POST, csrf_context=request)
     resource = request.context.resource
     if form.validate():
         for postprocess_conf in resource.postprocess_conf:
             if postprocess_conf.pkey == int(request.GET['pkey']):
                 # remove rule
                 DBSession.delete(postprocess_conf)
     return True
 
 
 @view_config(route_name='applications_property',
              match_param='key=report_graphs', renderer='json',
              permission='view')
 @view_config(route_name='applications_property',
              match_param='key=slow_report_graphs', renderer='json',
              permission='view')
 def get_application_report_stats(request):
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     if not filter_settings.get('start_date'):
         delta = timedelta(hours=1)
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     result = ReportGroupService.get_report_stats(request, filter_settings)
     return result
 
 
 @view_config(route_name='applications_property',
              match_param='key=metrics_graphs', renderer='json',
              permission='view')
 def metrics_graphs(request):
     """
     Handles metric dashboard graphs
     Returns information for time/tier breakdown
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     delta = timedelta(hours=1)
     if not filter_settings.get('start_date'):
         filter_settings['start_date'] = filter_settings['end_date'] - delta
     if filter_settings['end_date'] <= filter_settings['start_date']:
         filter_settings['end_date'] = filter_settings['start_date']
 
     delta = filter_settings['end_date'] - filter_settings['start_date']
     if delta < h.time_deltas.get('12h')['delta']:
         divide_by_min = 1
     elif delta <= h.time_deltas.get('3d')['delta']:
         divide_by_min = 5.0
     elif delta >= h.time_deltas.get('2w')['delta']:
         divide_by_min = 60.0 * 24
     else:
         divide_by_min = 60.0
 
     results = RequestMetricService.get_metrics_stats(
         request, filter_settings)
     # because requests are PER SECOND / we divide 1 min stats by 60
     # requests are normalized to 1 min average
     # results are average seconds time spent per request in specific area
     for point in results:
         if point['requests']:
             point['main'] = (point['main'] - point['sql'] -
                              point['nosql'] - point['remote'] -
                              point['tmpl'] -
                              point['custom']) / point['requests']
             point['sql'] = point['sql'] / point['requests']
             point['nosql'] = point['nosql'] / point['requests']
             point['remote'] = point['remote'] / point['requests']
             point['tmpl'] = point['tmpl'] / point['requests']
             point['custom'] = point['custom'] / point['requests']
             point['requests_2'] = point['requests'] / 60.0 / divide_by_min
 
     selected_types = ['main', 'sql', 'nosql', 'remote', 'tmpl', 'custom']
 
     for point in results:
         for stat_type in selected_types:
             point[stat_type] = round(point.get(stat_type, 0), 3)
 
     return results
 
 
 @view_config(route_name='applications_property',
              match_param='key=response_graphs', renderer='json',
              permission='view')
 def response_graphs(request):
     """
     Handles dashboard infomation for avg. response time split by today,
     2 days ago and week ago
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     delta = timedelta(hours=1)
     if not filter_settings.get('start_date'):
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     result_now = RequestMetricService.get_metrics_stats(
         request, filter_settings)
 
     filter_settings_2d = filter_settings.copy()
     filter_settings_2d['start_date'] = filter_settings['start_date'] - \
                                        timedelta(days=2)
     filter_settings_2d['end_date'] = filter_settings['end_date'] - \
                                      timedelta(days=2)
     result_2d = RequestMetricService.get_metrics_stats(
         request, filter_settings_2d)
 
     filter_settings_7d = filter_settings.copy()
     filter_settings_7d['start_date'] = filter_settings['start_date'] - \
                                        timedelta(days=7)
     filter_settings_7d['end_date'] = filter_settings['end_date'] - \
                                      timedelta(days=7)
     result_7d = RequestMetricService.get_metrics_stats(
         request, filter_settings_7d)
 
     plot_data = []
 
     for item in result_now:
         point = {'x': item['x'], 'today': 0, 'days_ago_2': 0,
                  'days_ago_7': 0}
         if item['requests']:
             point['today'] = round(item['main'] / item['requests'], 3)
         plot_data.append(point)
 
     for i, item in enumerate(result_2d[:len(plot_data)]):
         plot_data[i]['days_ago_2'] = 0
         point = result_2d[i]
         if point['requests']:
             plot_data[i]['days_ago_2'] = round(point['main'] /
                                                point['requests'], 3)
 
     for i, item in enumerate(result_7d[:len(plot_data)]):
         plot_data[i]['days_ago_7'] = 0
         point = result_7d[i]
         if point['requests']:
             plot_data[i]['days_ago_7'] = round(point['main'] /
                                                point['requests'], 3)
 
     return plot_data
 
 
 @view_config(route_name='applications_property',
              match_param='key=requests_graphs', renderer='json',
              permission='view')
 def requests_graphs(request):
     """
     Handles dashboard infomation for avg. response time split by today,
     2 days ago and week ago
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     delta = timedelta(hours=1)
     if not filter_settings.get('start_date'):
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     result_now = RequestMetricService.get_metrics_stats(
         request, filter_settings)
 
     delta = filter_settings['end_date'] - filter_settings['start_date']
     if delta < h.time_deltas.get('12h')['delta']:
         seconds = h.time_deltas['1m']['minutes'] * 60.0
     elif delta <= h.time_deltas.get('3d')['delta']:
         seconds = h.time_deltas['5m']['minutes'] * 60.0
     elif delta >= h.time_deltas.get('2w')['delta']:
         seconds = h.time_deltas['24h']['minutes'] * 60.0
     else:
         seconds = h.time_deltas['1h']['minutes'] * 60.0
 
     for item in result_now:
         if item['requests']:
             item['requests'] = round(item['requests'] / seconds, 3)
     return result_now
 
 
 @view_config(route_name='applications_property',
              match_param='key=apdex_stats', renderer='json',
              permission='view')
 def get_apdex_stats(request):
     """
     Returns information and calculates APDEX score per server for dashboard
     server information (upper right stats boxes)
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
     # make sure we have only one resource here to don't produce
     # weird results when we have wrong app in app selector
     filter_settings['resource'] = [filter_settings['resource'][0]]
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     delta = timedelta(hours=1)
     if not filter_settings.get('start_date'):
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     return RequestMetricService.get_apdex_stats(request, filter_settings)
 
 
 @view_config(route_name='applications_property', match_param='key=slow_calls',
              renderer='json', permission='view')
 def get_slow_calls(request):
     """
     Returns information for time consuming calls in specific time interval
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     delta = timedelta(hours=1)
     if not filter_settings.get('start_date'):
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     return SlowCallService.get_time_consuming_calls(request, filter_settings)
 
 
 @view_config(route_name='applications_property',
              match_param='key=requests_breakdown',
              renderer='json', permission='view')
 def get_requests_breakdown(request):
     """
     Used on dashboard to get information which views are most used in
     a time interval
     """
     query_params = request.GET.mixed()
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     if not filter_settings.get('start_date'):
         delta = timedelta(hours=1)
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     series = RequestMetricService.get_requests_breakdown(
         request, filter_settings)
 
     results = []
     for row in series:
         d_row = {'avg_response': round(row['main'] / row['requests'], 3),
                  'requests': row['requests'],
                  'main': row['main'],
                  'view_name': row['key'],
                  'latest_details': row['latest_details'],
                  'percentage': round(row['percentage'] * 100, 1)}
 
         results.append(d_row)
 
     return results
 
 
 @view_config(route_name='applications_property',
              match_param='key=trending_reports', renderer='json',
              permission='view')
 def trending_reports(request):
     """
     Returns exception/slow reports trending for specific time interval
     """
     query_params = request.GET.mixed().copy()
     # pop report type to rewrite it to tag later
     report_type = query_params.pop('report_type', None)
     if report_type:
         query_params['type'] = report_type
 
     query_params['resource'] = (request.context.resource.resource_id,)
 
     filter_settings = build_filter_settings_from_query_dict(request,
                                                             query_params)
 
     if not filter_settings.get('end_date'):
         end_date = datetime.utcnow().replace(microsecond=0, second=0)
         filter_settings['end_date'] = end_date
 
     if not filter_settings.get('start_date'):
         delta = timedelta(hours=1)
         filter_settings['start_date'] = filter_settings['end_date'] - delta
 
     results = ReportGroupService.get_trending(request, filter_settings)
 
     trending = []
     for occurences, group in results:
         report_group = group.get_dict(request)
         # show the occurences in time range instead of global ones
         report_group['occurences'] = occurences
         trending.append(report_group)
 
     return trending
 
 
 @view_config(route_name='applications_property',
              match_param='key=integrations',
              renderer='json', permission='view')
 def integrations(request):
     """
     Integration list for given application
     """
     application = request.context.resource
     return {'resource': application}
 
 
 @view_config(route_name='applications_property',
              match_param='key=user_permissions', renderer='json',
              permission='owner', request_method='POST')
 def user_resource_permission_create(request):
     """
     Set new permissions for user for a resource
     """
     resource = request.context.resource
     user_name = request.unsafe_json_body.get('user_name')
     user = UserService.by_user_name(user_name)
     if not user:
         user = UserService.by_email(user_name)
     if not user:
         return False
 
     for perm_name in request.unsafe_json_body.get('permissions', []):
         permission = UserResourcePermissionService.by_resource_user_and_perm(
             user.id, perm_name, resource.resource_id)
         if not permission:
             permission = UserResourcePermission(perm_name=perm_name,
                                                 user_id=user.id)
             resource.user_permissions.append(permission)
     DBSession.flush()
     perms = [p.perm_name for p in ResourceService.perms_for_user(resource, user)
              if p.type == 'user']
     result = {'user_name': user.user_name,
               'permissions': list(set(perms))}
     return result
 
 
 @view_config(route_name='applications_property',
              match_param='key=user_permissions', renderer='json',
              permission='owner', request_method='DELETE')
 def user_resource_permission_delete(request):
     """
     Removes user permission from specific resource
     """
     resource = request.context.resource
 
     user = UserService.by_user_name(request.GET.get('user_name'))
     if not user:
         return False
 
     for perm_name in request.GET.getall('permissions'):
         permission = UserResourcePermissionService.by_resource_user_and_perm(
             user.id, perm_name, resource.resource_id)
         resource.user_permissions.remove(permission)
     DBSession.flush()
     perms = [p.perm_name for p in ResourceService.perms_for_user(resource, user)
              if p.type == 'user']
     result = {'user_name': user.user_name,
               'permissions': list(set(perms))}
     return result
 
 
 @view_config(route_name='applications_property',
              match_param='key=group_permissions', renderer='json',
              permission='owner', request_method='POST')
 def group_resource_permission_create(request):
     """
     Set new permissions for group for a resource
     """
     resource = request.context.resource
     group = GroupService.by_id(request.unsafe_json_body.get('group_id'))
     if not group:
         return False
 
     for perm_name in request.unsafe_json_body.get('permissions', []):
         permission = GroupResourcePermissionService.by_resource_group_and_perm(
             group.id, perm_name, resource.resource_id)
         if not permission:
             permission = GroupResourcePermission(perm_name=perm_name,
                                                  group_id=group.id)
             resource.group_permissions.append(permission)
     DBSession.flush()
     perm_tuples = ResourceService.groups_for_perm(
         resource,
         ANY_PERMISSION,
         limit_group_permissions=True,
         group_ids=[group.id])
     perms = [p.perm_name for p in perm_tuples if p.type == 'group']
     result = {'group': group.get_dict(),
               'permissions': list(set(perms))}
     return result
 
 
 @view_config(route_name='applications_property',
              match_param='key=group_permissions', renderer='json',
              permission='owner', request_method='DELETE')
 def group_resource_permission_delete(request):
     """
     Removes group permission from specific resource
     """
     form = forms.ReactorForm(request.POST, csrf_context=request)
     form.validate()
     resource = request.context.resource
     group = GroupService.by_id(request.GET.get('group_id'))
     if not group:
         return False
 
     for perm_name in request.GET.getall('permissions'):
         permission = GroupResourcePermissionService.by_resource_group_and_perm(
             group.id, perm_name, resource.resource_id)
         resource.group_permissions.remove(permission)
     DBSession.flush()
     perm_tuples = ResourceService.groups_for_perm(
         resource,
         ANY_PERMISSION,
         limit_group_permissions=True,
         group_ids=[group.id])
     perms = [p.perm_name for p in perm_tuples if p.type == 'group']
     result = {'group': group.get_dict(),
               'permissions': list(set(perms))}
     return result

backend/src/appenlight/views/tests.py

@@ -1,446 +1,445 b''
 # -*- coding: utf-8 -*-
 
 # Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # 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.
 
 import copy
 import logging
 import datetime
 import time
 import random
 import redis
-import six
 import pyramid.renderers
 import requests
 
 from ziggurat_foundations.models.services.user import UserService
 
 import appenlight.celery.tasks
 from pyramid.view import view_config
 from pyramid_mailer.message import Message
 from appenlight_client.timing import time_trace
 from appenlight.models import DBSession, Datastores
 from appenlight.models.user import User
 from appenlight.models.report_group import ReportGroup
 from appenlight.models.event import Event
 from appenlight.models.services.report_group import ReportGroupService
 from appenlight.models.services.event import EventService
 from appenlight.lib.enums import ReportType
 
 log = logging.getLogger(__name__)
 
 GLOBAL_REQ = None
 
 
 @view_config(route_name='test', match_param='action=mail',
              renderer='string', permission='root_administration')
 def mail(request):
     """
     Test email communication
     """
     request.environ['HTTP_HOST'] = 'appenlight.com'
     request.environ['wsgi.url_scheme'] = 'https'
     renderer_vars = {"title": "You have just registered on AppEnlight",
                      "username": "test",
                      "email": "grzegżółka",
                      'firstname': 'dupa'}
     # return vars
     html = pyramid.renderers.render('/email_templates/registered.jinja2',
                                     renderer_vars,
                                     request=request)
     message = Message(subject="hello world %s" % random.randint(1, 9999),
                       sender="[e-mail]",
                       recipients=["[e-mail]"],
                       html=html)
     request.registry.mailer.send(message)
     return html
     return vars
 
 
 @view_config(route_name='test', match_param='action=alerting',
              renderer='appenlight:templates/tests/alerting.jinja2',
              permission='root_administration')
 def alerting_test(request):
     """
     Allows to test send data on various registered alerting channels
     """
     applications = UserService.resources_with_perms(request.user, ['view'], resource_types=['application'])
     # what we can select in total
     all_possible_app_ids = [app.resource_id for app in applications]
     resource = applications[0]
 
     alert_channels = []
     for channel in request.user.alert_channels:
         alert_channels.append(channel.get_dict())
 
     cname = request.params.get('channel_name')
     cvalue = request.params.get('channel_value')
     event_name = request.params.get('event_name')
     if cname and cvalue:
         for channel in request.user.alert_channels:
             if (channel.channel_value == cvalue and
                         channel.channel_name == cname):
                 break
         if event_name in ['error_report_alert', 'slow_report_alert']:
             # opened
             new_event = Event(resource_id=resource.resource_id,
                               event_type=Event.types[event_name],
                               start_date=datetime.datetime.utcnow(),
                               status=Event.statuses['active'],
                               values={'reports': 5,
                                       'threshold': 10}
                               )
             channel.notify_alert(resource=resource,
                                  event=new_event,
                                  user=request.user,
                                  request=request)
 
             # closed
             ev_type = Event.types[event_name.replace('open', 'close')]
             new_event = Event(resource_id=resource.resource_id,
                               event_type=ev_type,
                               start_date=datetime.datetime.utcnow(),
                               status=Event.statuses['closed'],
                               values={'reports': 5,
                                       'threshold': 10})
             channel.notify_alert(resource=resource,
                                  event=new_event,
                                  user=request.user,
                                  request=request)
         elif event_name == 'notify_reports':
             report = ReportGroupService.by_app_ids(all_possible_app_ids) \
                 .filter(ReportGroup.report_type == ReportType.error).first()
             confirmed_reports = [(5, report), (1, report)]
             channel.notify_reports(resource=resource,
                                    user=request.user,
                                    request=request,
                                    since_when=datetime.datetime.utcnow(),
                                    reports=confirmed_reports)
             confirmed_reports = [(5, report)]
             channel.notify_reports(resource=resource,
                                    user=request.user,
                                    request=request,
                                    since_when=datetime.datetime.utcnow(),
                                    reports=confirmed_reports)
         elif event_name == 'notify_uptime':
             new_event = Event(resource_id=resource.resource_id,
                               event_type=Event.types['uptime_alert'],
                               start_date=datetime.datetime.utcnow(),
                               status=Event.statuses['active'],
                               values={"status_code": 500,
                                       "tries": 2,
                                       "response_time": 0})
             channel.notify_uptime_alert(resource=resource,
                                         event=new_event,
                                         user=request.user,
                                         request=request)
         elif event_name == 'chart_alert':
             event = EventService.by_type_and_status(
                 event_types=(Event.types['chart_alert'],),
                 status_types=(Event.statuses['active'],)).first()
             channel.notify_chart_alert(resource=event.resource,
                                        event=event,
                                        user=request.user,
                                        request=request)
         elif event_name == 'daily_digest':
             since_when = datetime.datetime.utcnow() - datetime.timedelta(
                 hours=8)
             filter_settings = {'resource': [resource.resource_id],
                                'tags': [{'name': 'type',
                                          'value': ['error'], 'op': None}],
                                'type': 'error', 'start_date': since_when}
 
             reports = ReportGroupService.get_trending(
                 request, filter_settings=filter_settings, limit=50)
             channel.send_digest(resource=resource,
                                 user=request.user,
                                 request=request,
                                 since_when=datetime.datetime.utcnow(),
                                 reports=reports)
 
     return {'alert_channels': alert_channels,
             'applications': dict([(app.resource_id, app.resource_name)
                                   for app in applications.all()])}
 
 
 @view_config(route_name='test', match_param='action=error',
              renderer='string', permission='root_administration')
 def error(request):
     """
     Raises an internal error with some test data for testing purposes
     """
     request.environ['appenlight.message'] = 'test message'
     request.environ['appenlight.extra']['dupa'] = 'dupa'
     request.environ['appenlight.extra']['message'] = 'message'
     request.environ['appenlight.tags']['action'] = 'test_error'
     request.environ['appenlight.tags']['count'] = 5
     log.debug(chr(960))
     log.debug('debug')
     log.info(chr(960))
     log.info('INFO')
     log.warning('warning')
 
     @time_trace(name='error.foobar', min_duration=0.1)
     def fooobar():
         time.sleep(0.12)
         return 1
 
     fooobar()
 
     def foobar(somearg):
         raise Exception('test')
 
     client = redis.StrictRedis()
     client.setex('testval', 10, 'foo')
     request.environ['appenlight.force_send'] = 1
 
     # stats, result = get_local_storage(local_timing).get_thread_stats()
     # import pprint
     # pprint.pprint(stats)
     # pprint.pprint(result)
     # print 'entries', len(result)
     request.environ['appenlight.username'] = 'ErgO'
     raise Exception(chr(960) + '%s' % random.randint(1, 5))
     return {}
 
 
 @view_config(route_name='test', match_param='action=task',
              renderer='string', permission='root_administration')
 def test_task(request):
     """
     Test erroneous celery task
     """
     import appenlight.celery.tasks
 
     appenlight.celery.tasks.test_exception_task.delay()
     return 'task sent'
 
 
 @view_config(route_name='test', match_param='action=task_retry',
              renderer='string', permission='root_administration')
 def test_task_retry(request):
     """
     Test erroneous celery task
     """
     import appenlight.celery.tasks
 
     appenlight.celery.tasks.test_retry_exception_task.delay()
     return 'task sent'
 
 
 @view_config(route_name='test', match_param='action=celery_emails',
              renderer='string', permission='root_administration')
 def test_celery_emails(request):
     import appenlight.celery.tasks
     appenlight.celery.tasks.alerting.delay()
     return 'task sent'
 
 
 @view_config(route_name='test', match_param='action=daily_digest',
              renderer='string', permission='root_administration')
 def test_celery_daily_digest(request):
     import appenlight.celery.tasks
     appenlight.celery.tasks.daily_digest.delay()
     return 'task sent'
 
 
 @view_config(route_name='test', match_param='action=celery_alerting',
              renderer='string', permission='root_administration')
 def test_celery_alerting(request):
     import appenlight.celery.tasks
     appenlight.celery.tasks.alerting()
     return 'task sent'
 
 
 @view_config(route_name='test', match_param='action=logging',
              renderer='string', permission='root_administration')
 def logs(request):
     """
     Test some in-app logging
     """
     log.debug(chr(960))
     log.debug('debug')
     log.info(chr(960))
     log.info('INFO')
     log.warning('Matched GET /\xc4\x85\xc5\xbc\xc4\x87'
                 '\xc4\x99\xc4\x99\xc4\x85/summary')
     log.warning('XXXXMatched GET /\xc4\x85\xc5\xbc\xc4'
                 '\x87\xc4\x99\xc4\x99\xc4\x85/summary')
     log.warning('DUPA /ążćęęą')
     log.warning("g\u017ceg\u017c\u00f3\u0142ka")
     log.error('TEST Lorem ipsum2',
               extra={'user': 'ergo', 'commit': 'sog8ds0g7sdih12hh1j512h5k'})
     log.fatal('TEST Lorem ipsum3')
     log.warning('TEST Lorem ipsum',
                 extra={"action": 'purchase',
                        "price": random.random() * 100,
                        "quantity": random.randint(1, 99)})
     log.warning('test_pkey',
                 extra={"action": 'test_pkey', "price": random.random() * 100,
                        'ae_primary_key': 1,
                        "quantity": random.randint(1, 99)})
     log.warning('test_pkey2',
                 extra={"action": 'test_pkey', "price": random.random() * 100,
                        'ae_primary_key': 'b',
                        'ae_permanent': 't',
                        "quantity": random.randint(1, 99)})
     log.warning('test_pkey3',
                 extra={"action": 'test_pkey', "price": random.random() * 100,
                        'ae_primary_key': 1,
                        "quantity": random.randint(1, 99)})
     log.warning('test_pkey4',
                 extra={"action": 'test_pkey', "price": random.random() * 100,
                        'ae_primary_key': 'b',
                        'ae_permanent': True,
                        "quantity": random.randint(1, 99)})
     request.environ['appenlight.force_send'] = 1
     return {}
 
 
 @view_config(route_name='test', match_param='action=transaction',
              renderer='string', permission='root_administration')
 def transaction_test(request):
     """
     Test transactions
     """
     try:
         result = DBSession.execute("SELECT 1/0")
     except:
         request.tm.abort()
     result = DBSession.execute("SELECT 1")
     return 'OK'
 
 
 @view_config(route_name='test', match_param='action=slow_request',
              renderer='string', permission='root_administration')
 def slow_request(request):
     """
     Test a request that has some slow entries - including nested calls
     """
     users = DBSession.query(User).all()
     import random
     some_val = random.random()
     import threading
     t_id = id(threading.currentThread())
     log.warning('slow_log %s %s ' % (some_val, t_id))
     log.critical('tid %s' % t_id)
 
     @time_trace(name='baz_func %s' % some_val, min_duration=0.1)
     def baz(arg):
         time.sleep(0.32)
         return arg
 
     requests.get('http://ubuntu.com')
 
     @time_trace(name='foo_func %s %s' % (some_val, t_id), min_duration=0.1)
     def foo(arg):
         time.sleep(0.52)
         log.warning('foo_func %s %s' % (some_val, t_id))
         requests.get('http://ubuntu.com?test=%s' % some_val)
         return bar(arg)
 
     @time_trace(name='bar_func %s %s' % (some_val, t_id), min_duration=0.1)
     def bar(arg):
         log.warning('bar_func %s %s' % (some_val, t_id))
         time.sleep(1.52)
         baz(arg)
         baz(arg)
         return baz(arg)
 
     foo('a')
     return {}
 
 
 @view_config(route_name='test', match_param='action=styling',
              renderer='appenlight:templates/tests/styling.jinja2',
              permission='__no_permission_required__')
 def styling(request):
     """
     Some styling test page
     """
     _ = str
     request.session.flash(_(
         'Your password got updated. '
         'Next time log in with your new credentials.'))
     request.session.flash(_(
         'Something went wrong when we '
         'tried to authorize you via external provider'),
         'warning')
     request.session.flash(_(
         'Unfortunately there was a problem '
         'processing your payment, please try again later.'),
         'error')
     return {}
 
 
 @view_config(route_name='test', match_param='action=js_error',
              renderer='appenlight:templates/tests/js_error.jinja2',
              permission='__no_permission_required__')
 def js(request):
     """
     Used for testing javasctipt client for error catching
     """
     return {}
 
 
 @view_config(route_name='test', match_param='action=js_log',
              renderer='appenlight:templates/tests/js_log.jinja2',
              permission='__no_permission_required__')
 def js_log(request):
     """
     Used for testing javasctipt client for logging
     """
     return {}
 
 
 @view_config(route_name='test', match_param='action=log_requests',
              renderer='string',
              permission='__no_permission_required__')
 def log_requests(request):
     """
     Util view for printing json requests
     """
     return {}
 
 
 @view_config(route_name='test', match_param='action=url', renderer='string',
              permission='__no_permission_required__')
 def log_requests(request):
     """
     I have no fucking clue why I needed that ;-)
     """
     return request.route_url('reports', _app_url='https://appenlight.com')
 
 
 class TestClass(object):
     """
     Used to test if class-based view name resolution works correctly
     """
 
     def __init__(self, request):
         self.request = request
 
     @view_config(route_name='test', match_param='action=test_a',
                  renderer='string', permission='root_administration')
     @view_config(route_name='test', match_param='action=test_c',
                  renderer='string', permission='root_administration')
     @view_config(route_name='test', match_param='action=test_d',
                  renderer='string', permission='root_administration')
     def test_a(self):
         return 'ok'
 
     @view_config(route_name='test', match_param='action=test_b',
                  renderer='string', permission='root_administration')
     def test_b(self):
         return 'ok'