Option to blacklist certain resources from AlertChannels

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

@@ -0,0 +1,30 b''
+"""connect resources to alert_channels
+
+Revision ID: e9fcfbdd9498
+Revises: 55b6e612672f
+Create Date: 2018-02-28 13:52:50.717217
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = 'e9fcfbdd9498'
+down_revision = '55b6e612672f'
+
+from alembic import op
+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')),
+        sa.Column('resource_id', sa.Integer,
+                  sa.ForeignKey('resources.resource_id',
+                                ondelete='CASCADE', onupdate='CASCADE'))
+    )
+
+
+def downgrade():
+    op.drop_table('channels_resources')

backend/src/appenlight/models/alert_channel.py

@@ -1,291 +1,305 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
 import urllib.request, urllib.parse, urllib.error
 from datetime import timedelta
 from appenlight.models import Base
 from appenlight.lib.utils.date_utils import convert_date
 from sqlalchemy.dialects.postgresql import JSON
 from ziggurat_foundations.models.base import BaseModel
 
 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'))
 )
 
+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'))
+)
+
 DATE_FRMT = '%Y-%m-%dT%H:%M'
 
 
 class AlertChannel(Base, BaseModel):
     """
     Stores information about possible alerting options
     """
     __tablename__ = 'alert_channels'
     __possible_channel_names__ = ['email']
     __mapper_args__ = {
         'polymorphic_on': 'channel_name',
         'polymorphic_identity': 'integration'
     }
 
     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)
     pkey = sa.Column(sa.Integer(), nullable=False, primary_key=True)
 
     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',
+                                    cascade="all, delete-orphan",
+                                    passive_deletes=True,
+                                    passive_updates=True,
+                                    secondary=channel_resources_m2m_table,
+                                    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.channel_value
         )
 
     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)
         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
 
         if extended_info:
             instance_dict['actions'] = [
                 rule.get_dict(extended_info=True) for
                 rule in self.channel_actions]
 
         del instance_dict['channel_json_conf']
 
         if self.integration:
             instance_dict[
                 '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)):
                 d[k] = instance_dict[k]
         return d
 
     def __repr__(self):
         return '<AlertChannel: (%s,%s), user:%s>' % (self.channel_name,
                                                      self.channel_value,
                                                      self.user_name,)
 
     def send_digest(self, **kwargs):
         """
         This should implement daily top error report notifications
         """
         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')
 
     def notify_alert(self, **kwargs):
         """
         Notify user of report/uptime/chart threshold events based on events alert
         type
 
         Kwargs:
             application: application that the event applies for,
             event: event that is notified,
             user: user that should be notified
             request: request object
 
         """
         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':
             self.notify_uptime_alert(**kwargs)
         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')
 
     def notify_report_alert(self, **kwargs):
         """
         This should implement report open/close alerts notifications
         """
         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')
 
     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
 
         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'),
             "url_start_date": url_start_date,
             "url_end_date": url_end_date
         }
         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()
         return tmpl_vars
 
     def report_alert_notification_vars(self, kwargs):
         tmpl_vars = self.get_notification_basic_vars(kwargs)
         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'
 
         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'
 
         app_url = kwargs['request'].registry.settings['_mail_url']
 
         destination_url = kwargs['request'].route_url('/',
                                                       _app_url=app_url)
         if alert_type:
             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)
             )
         else:
             destination_url += 'ui/{}?resource={}'.format(
                 tmpl_vars["url_report_type"],
                 tmpl_vars['resource'].resource_id
             )
         tmpl_vars["destination_url"] = destination_url
 
         return tmpl_vars
 
     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.'
         elif e_values:
             code = e_values.get('status_code')
             reason += ' Response status code: %s.' % code
 
         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)
             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'])
         end_date = None
         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)
         to_encode = {
             '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)
 
         destination_url += 'ui/{}?{}'.format(
             'logs',
             urllib.parse.urlencode(to_encode)
         )
         tmpl_vars['destination_url'] = destination_url
         return tmpl_vars

backend/src/appenlight/models/event.py

@@ -1,155 +1,160 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
 import logging
 
 from datetime import datetime
 from appenlight.models import Base, get_db_session
 from appenlight.models.services.report_stat import ReportStatService
 from appenlight.models.resource import Resource
 from appenlight.models.integrations import IntegrationException
 from pyramid.threadlocal import get_current_request
 from sqlalchemy.dialects.postgresql import JSON
 from ziggurat_foundations.models.base import BaseModel
 
 log = logging.getLogger(__name__)
 
 
 class Event(Base, BaseModel):
     __tablename__ = 'events'
 
     types = {'error_report_alert': 1,
              'slow_report_alert': 3,
              'comment': 5,
              'assignment': 6,
              'uptime_alert': 7,
              'chart_alert': 9}
 
     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)
     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(),
                                             self.resource_id,
                                             self.unified_alert_action())
 
     @property
     def reverse_types(self):
         return dict([(v, k) for k, v in self.types.items()])
 
     def unified_alert_name(self):
         return self.reverse_types[self.event_type]
 
     def unified_alert_action(self):
         event_name = self.reverse_types[self.event_type]
         if self.status == Event.statuses['closed']:
             return "CLOSE"
         if self.status != Event.statuses['closed']:
             return "OPEN"
         return event_name
 
     def send_alerts(self, request=None, resource=None, db_session=None):
         """" Sends alerts to applicable channels """
         db_session = get_db_session(db_session)
         db_session.flush()
         if not resource:
             resource = Resource.by_resource_id(self.resource_id)
         if not request:
             request = get_current_request()
         if not resource:
             return
         users = set([p.user for p in resource.users_for_perm('view')])
         for user in users:
             for channel in user.alert_channels:
-                if not channel.channel_validated or not channel.send_alerts:
+                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
+                ):
                     continue
                 else:
                     try:
                         channel.notify_alert(resource=resource,
                                              event=self,
                                              user=user,
                                              request=request)
                     except IntegrationException as 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']]
         app = Resource.by_resource_id(self.resource_id)
         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:
                 threshold = app.error_report_threshold
             if Event.types['slow_report_alert'] == self.event_type:
                 threshold = app.slow_report_threshold
 
             if total < threshold:
                 self.close()
 
     def close(self, db_session=None):
         """
         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.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'
 
         alert_action = self.unified_alert_action()
         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
         return dict_data