flapjack 0.7.28 → 0.7.29

data/lib/flapjack/data/contact.rb

@@ -25,7 +25,7 @@ module Flapjack
         raise "Redis connection not set" unless redis = options[:redis]
 
         redis.keys('contact:*').inject([]) {|ret, k|
-          k =~ /^contact:(\d+)$/
+          k =~ /^contact:(.*)$/
           id = $1
           contact = self.find_by_id(id, :redis => redis)
           ret << contact if contact
@@ -129,6 +129,12 @@ module Flapjack
           merge('service_key' => service_key)
       end
 
+      def set_pagerduty_credentials(details)
+        @redis.hset("contact_media:#{self.id}", 'pagerduty', details['service_key'])
+        @redis.hmset("contact_pagerduty:#{self.id}",
+                     *['subdomain', 'username', 'password'].collect {|f| [f, details[f]]})
+      end
+
       # NB ideally contacts_for:* keys would scope the entity and check by an
       # input source, for namespacing purposes
       def entities(options = {})
@@ -211,6 +217,7 @@ module Flapjack
       end
 
       def set_interval_for_media(media, interval)
+        return if 'pagerduty'.eql?(media)
         if interval.nil?
           @redis.hdel("contact_media_intervals:#{self.id}", media)
           return
@@ -225,6 +232,7 @@ module Flapjack
       end
 
       def set_rollup_threshold_for_media(media, threshold)
+        return if 'pagerduty'.eql?(media)
         if threshold.nil?
           @redis.hdel("contact_media_rollup_thresholds:#{self.id}", media)
           return
@@ -234,12 +242,8 @@ module Flapjack
       end
 
       def set_address_for_media(media, address)
+        return if 'pagerduty'.eql?(media)
         @redis.hset("contact_media:#{self.id}", media, address)
-        if media == 'pagerduty'
-          # FIXME - work out what to do when changing the pagerduty service key (address)
-          # probably best solution is to remove the need to have the username and password
-          # and subdomain as pagerduty's updated api's mean we don't them anymore I think...
-        end
         self.media = @redis.hgetall("contact_media:#{@id}")
       end
 
@@ -312,10 +316,13 @@ module Flapjack
         key = "contact_alerting_checks:#{self.id}:media:#{media}"
         cleaned = 0
         alerting_checks_for_media(media).each do |check|
+          entity_check = Flapjack::Data::EntityCheck.for_event_id(check, :redis => @redis)
           next unless Flapjack::Data::EntityCheck.state_for_event_id?(check, :redis => @redis) == 'ok' ||
             Flapjack::Data::EntityCheck.in_unscheduled_maintenance_for_event_id?(check, :redis => @redis) ||
-            Flapjack::Data::EntityCheck.in_scheduled_maintenance_for_event_id?(check, :redis => @redis)
+            Flapjack::Data::EntityCheck.in_scheduled_maintenance_for_event_id?(check, :redis => @redis) ||
+            !entity_check.contacts.map {|c| c.id}.include?(self.id)
 
+          # FIXME: why can't i get this logging when called from notifier (notification.rb)?
           @logger.debug("removing from alerting checks for #{self.id}/#{media}: #{check}") if @logger
           remove_alerting_check_for_media(media, check)
           cleaned += 1

data/lib/flapjack/data/entity_check.rb

@@ -30,9 +30,10 @@ module Flapjack
       # TODO probably shouldn't always be creating on query -- work out when this should be happening
       def self.for_event_id(event_id, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
+        logger = options[:logger]
         entity_name, check = event_id.split(':', 2)
-        self.new(Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis, :create => true), check,
-          :redis => redis)
+        self.new(Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis, :create => true, :logger => true), check,
+          :redis => redis, :logger => logger)
       end
 
       # TODO probably shouldn't always be creating on query -- work out when this should be happening
@@ -533,7 +534,7 @@ module Flapjack
         end
 
         entity.contacts + contact_ids.collect {|c_id|
-          Flapjack::Data::Contact.find_by_id(c_id, :redis => @redis)
+          Flapjack::Data::Contact.find_by_id(c_id, :redis => @redis, :logger => @logger)
         }.compact
       end
 

data/lib/flapjack/data/notification.rb

@@ -61,10 +61,8 @@ module Flapjack
                  'last_state'     => last_state[:state],
                  'last_summary'   => last_state[:summary],
                  'state_duration' => opts[:state_duration],
-
                  'type'           => opts[:type] || type_for_event(event),
                  'severity'       => opts[:severity],
-
                  'tags'           => tag_data }
 
         redis.rpush(queue, Oj.dump(notif))
@@ -94,11 +92,15 @@ module Flapjack
       end
 
       def ok?
-        @state && ['ok', 'up'].include?(@state.downcase)
+        @state && ['ok', 'up'].include?(@state)
       end
 
       def acknowledgement?
-        @state && ['acknowledgement'].include?(@state.downcase)
+        @state && ['acknowledgement'].include?(@state)
+      end
+
+      def test?
+        @state && ['test_notifications'].include?(@state)
       end
 
       def contents
@@ -123,7 +125,7 @@ module Flapjack
         default_timezone = opts[:default_timezone]
         logger = opts[:logger]
 
-        @messages ||= contacts.collect {|contact|
+        @messages ||= contacts.collect do |contact|
           contact_id = contact.id
           rules = contact.notification_rules
           media = contact.media
@@ -195,36 +197,39 @@ module Flapjack
           logger.debug "media_to_use: #{media_to_use}"
 
           # here begins rollup madness
-          media_to_use.each_pair.inject([]) { |ret, (media, address)|
+          media_to_use.each_pair.inject([]) do |ret, (media, address)|
             rollup_type = nil
 
-            contact.add_alerting_check_for_media(media, @event_id) unless ok? || acknowledgement?
+            contact.add_alerting_check_for_media(media, @event_id) unless ok? || acknowledgement? || test?
 
             # expunge checks in (un)scheduled maintenance from the alerting set
             cleaned = contact.clean_alerting_checks_for_media(media)
             logger.debug("cleaned alerting checks for #{media}: #{cleaned}")
 
-            alerting_checks  = contact.count_alerting_checks_for_media(media)
-            rollup_threshold = contact.rollup_threshold_for_media(media)
-            case
-            when rollup_threshold.nil?
-              # back away slowly
-            when alerting_checks >= rollup_threshold
-              next ret if contact.drop_rollup_notifications_for_media?(media)
-              contact.update_sent_rollup_alert_keys_for_media(media, :delete => ok?)
-              rollup_type = 'problem'
-            when (alerting_checks + cleaned >= rollup_threshold)
-              # alerting checks was just cleaned such that it is now below the rollup threshold
-              rollup_type = 'recovery'
+            # pagerduty is an example of a medium which should never be rolled up
+            unless ['pagerduty'].include?(media)
+              alerting_checks  = contact.count_alerting_checks_for_media(media)
+              rollup_threshold = contact.rollup_threshold_for_media(media)
+              case
+              when rollup_threshold.nil?
+                # back away slowly
+              when alerting_checks >= rollup_threshold
+                next ret if contact.drop_rollup_notifications_for_media?(media)
+                contact.update_sent_rollup_alert_keys_for_media(media, :delete => ok?)
+                rollup_type = 'problem'
+              when (alerting_checks + cleaned >= rollup_threshold)
+                # alerting checks was just cleaned such that it is now below the rollup threshold
+                rollup_type = 'recovery'
+              end
+              logger.debug "rollup decisions: #{@event_id} #{@state} #{media} #{address} rollup_type: #{rollup_type}"
             end
-            logger.debug "rollup decisions: #{@event_id} #{@state} #{media} #{address} rollup_type: #{rollup_type}"
 
             m = Flapjack::Data::Message.for_contact(contact,
                   :medium => media, :address => address, :rollup => rollup_type)
             ret << m
             ret
-          }
-        }.compact.flatten
+          end
+        end.compact.flatten # @messages ||= contacts.collect do ...
       end
 
     private
@@ -238,16 +243,12 @@ module Flapjack
         @time           = opts['time']
         @count          = opts['count']
         @duration       = opts['duration']
-
         @last_state     = opts['last_state']
         @last_summary   = opts['last_summary']
         @state_duration = opts['state_duration']
-
         @type           = opts['type']
         @severity       = opts['severity']
-
-        tags            = opts['tags']
-        @tags           = tags.is_a?(Array) ? Flapjack::Data::TagSet.new(tags) : nil
+        @tags           = opts['tags'].is_a?(Array) ? Flapjack::Data::TagSet.new(opts['tags']) : nil
       end
 
       # # time restrictions match?

data/lib/flapjack/gateways/api/contact_methods.rb

@@ -97,8 +97,11 @@ module Flapjack
           # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts
           app.get '/contacts' do
             content_type :json
-
-            Flapjack::Data::Contact.all(:redis => redis).to_json
+            "[" +
+              Flapjack::Data::Contact.all(:redis => redis).map do |contact|
+                contact.to_json
+              end.join(',') +
+              "]"
           end
 
           # Returns the core information about the specified contact
@@ -233,19 +236,36 @@ module Flapjack
 
             contact = find_contact(params[:contact_id])
             errors = []
-            if params[:address].nil?
-              errors << "no address for '#{params[:id]}' media"
-            end
 
-            halt err(403, *errors) unless errors.empty?
+            if 'pagerduty'.eql?(params[:id])
+              errors = [:service_key, :subdomain, :username, :password].inject([]) do |memo, pdp|
+                memo << "no #{pdp.to_s} for 'pagerduty' media" if params[pdp].nil?
+                memo
+              end
+
+              halt err(403, *errors) unless errors.empty?
+
+              contact.set_pagerduty_credentials('service_key'  => params[:service_key],
+                                                'subdomain'    => params[:subdomain],
+                                                'username'     => params[:username],
+                                                'password'     => params[:password])
 
-            contact.set_address_for_media(params[:id], params[:address])
-            contact.set_interval_for_media(params[:id], params[:interval])
-            contact.set_rollup_threshold_for_media(params[:id], params[:rollup_threshold])
+              contact.pagerduty_credentials.to_json
+            else
+              if params[:address].nil?
+                errors << "no address for '#{params[:id]}' media"
+              end
+
+              halt err(403, *errors) unless errors.empty?
 
-            {'address'          => contact.media[params[:id]],
-             'interval'         => contact.media_intervals[params[:id]],
-             'rollup_threshold' => contact.media_rollup_thresholds[params[:id]]}.to_json
+              contact.set_address_for_media(params[:id], params[:address])
+              contact.set_interval_for_media(params[:id], params[:interval])
+              contact.set_rollup_threshold_for_media(params[:id], params[:rollup_threshold])
+
+              {'address'          => contact.media[params[:id]],
+               'interval'         => contact.media_intervals[params[:id]],
+               'rollup_threshold' => contact.media_rollup_thresholds[params[:id]]}.to_json
+            end
           end
 
           # delete a media of a contact

data/lib/flapjack/gateways/email.rb

@@ -12,6 +12,7 @@ require 'em/protocols/smtpclient'
 require 'flapjack/utility'
 
 require 'flapjack/data/entity_check'
+require 'flapjack/data/alert'
 
 module Flapjack
   module Gateways
@@ -31,46 +32,22 @@ module Flapjack
         end
 
         # TODO refactor to remove complexity
-        def perform(notification)
-          prepare( notification )
-          deliver( notification )
+        def perform(contents)
+          @logger.debug "Woo, got an alert to send out: #{contents.inspect}"
+          alert = prepare(contents)
+          deliver(alert)
         end
 
         # sets a bunch of class instance variables for each email
-        def prepare(notification)
-          @logger.debug "Woo, got a notification to send out: #{notification.inspect}"
-
-          # The instance variables are referenced by the templates, which
-          # share the current binding context
-          @notification_type   = notification['notification_type']
-          @notification_id     = notification['id'] || SecureRandom.uuid
-          @rollup              = notification['rollup']
-          @rollup_alerts       = notification['rollup_alerts']
-          @rollup_threshold    = notification['rollup_threshold']
-          @contact_first_name  = notification['contact_first_name']
-          @contact_last_name   = notification['contact_last_name']
-          @state               = notification['state']
-          @duration            = notification['state_duration']
-          @summary             = notification['summary']
-          @last_state          = notification['last_state']
-          @last_summary        = notification['last_summary']
-          @details             = notification['details']
-          @time                = notification['time']
-          @entity_name, @check = notification['event_id'].split(':', 2)
-
-          entity_check = Flapjack::Data::EntityCheck.for_event_id(notification['event_id'],
-            :redis => @redis)
-
-          @in_unscheduled_maintenance = entity_check.in_scheduled_maintenance?
-          @in_scheduled_maintenance   = entity_check.in_unscheduled_maintenance?
-
+        def prepare(contents)
+          Flapjack::Data::Alert.new(contents, :logger => @logger)
         rescue => e
-          @logger.error "Error preparing email to #{m_to}: #{e.class}: #{e.message}"
+          @logger.error "Error preparing email to #{contents['address']}: #{e.class}: #{e.message}"
           @logger.error e.backtrace.join("\n")
           raise
         end
 
-        def deliver(notification)
+        def deliver(alert)
           host = @smtp_config ? @smtp_config['host'] : nil
           port = @smtp_config ? @smtp_config['port'] : nil
           starttls = @smtp_config ? !! @smtp_config['starttls'] : nil
@@ -85,21 +62,21 @@ module Flapjack
 
           m_from = "flapjack@#{@fqdn}"
           @logger.debug("flapjack_mailer: set from to #{m_from}")
-          m_reply_to = m_from
-          m_to       = notification['address']
-
 
-          mail = prepare_email(:from => m_from,
-                               :to   => m_to)
+          mail = prepare_email(:from       => m_from,
+                               :to         => alert.address,
+                               :message_id => "<#{alert.notification_id}@#{@fqdn}>",
+                               :alert      => alert)
 
           smtp_args = {:from     => m_from,
-                       :to       => m_to,
+                       :to       => alert.address,
                        :content  => "#{mail.to_s}\r\n.\r\n",
                        :domain   => @fqdn,
                        :host     => host || 'localhost',
                        :port     => port || 25,
                        :starttls => starttls}
           smtp_args.merge!(:auth => auth) if auth
+
           email = EM::P::SmtpClient.send(smtp_args)
 
           response = EM::Synchrony.sync(email)
@@ -107,45 +84,64 @@ module Flapjack
           # http://tools.ietf.org/html/rfc821#page-36 SMTP response codes
           if response && response.respond_to?(:code) &&
             ((response.code == 250) || (response.code == 251))
-            @logger.info "Email sending succeeded"
+            alert.record_send_success!
             @sent += 1
           else
             @logger.error "Email sending failed"
           end
 
-          @logger.info "Email response: #{response.inspect}"
+          @logger.debug "Email response: #{response.inspect}"
 
         rescue => e
-          @logger.error "Error delivering email to #{m_to}: #{e.class}: #{e.message}"
+          @logger.error "Error generating or delivering email to #{alert.address}: #{e.class}: #{e.message}"
           @logger.error e.backtrace.join("\n")
           raise
         end
 
         private
 
+        # returns a Mail object
         def prepare_email(opts = {})
           from       = opts[:from]
           to         = opts[:to]
-          message_id = "<#{@notification_id}@#{@fqdn}>"
+          message_id = opts[:message_id]
+          alert      = opts[:alert]
 
           message_type = case
-          when @rollup
+          when alert.rollup
             'rollup'
           else
             'alert'
           end
 
-          subject_template = ERB.new(File.read(File.dirname(__FILE__) +
-            "/email/#{message_type}_subject.text.erb"), nil, '-')
+          mydir = File.dirname(__FILE__)
+
+          subject_template_path = mydir + "/email/#{message_type}_subject.text.erb"
+          text_template_path    = mydir + "/email/#{message_type}.text.erb"
+          html_template_path    = mydir + "/email/#{message_type}.html.erb"
 
-          text_template = ERB.new(File.read(File.dirname(__FILE__) +
-            "/email/#{message_type}.text.erb"), nil, '-')
+          subject_template = ERB.new(File.read(subject_template_path), nil, '-')
+          text_template    = ERB.new(File.read(text_template_path), nil, '-')
+          html_template    = ERB.new(File.read(html_template_path), nil, '-')
 
-          html_template = ERB.new(File.read(File.dirname(__FILE__) +
-            "/email/#{message_type}.html.erb"), nil, '-')
+          @alert  = alert
+          bnd     = binding
 
-          bnd        = binding
-          subject    = subject_template.result(bnd).chomp
+          # do some intelligence gathering in case an ERB execution blows up
+          begin
+            erb_to_be_executed = subject_template_path
+            subject = subject_template.result(bnd).chomp
+
+            erb_to_be_executed = text_template_path
+            body_text = text_template.result(bnd)
+
+            erb_to_be_executed = html_template_path
+            body_html = html_template.result(bnd)
+          rescue => e
+            @logger.error "Error while excuting ERBs for an email: " +
+              "ERB being executed: #{erb_to_be_executed}"
+            raise
+          end
 
           @logger.debug("preparing email to: #{to}, subject: #{subject}, message-id: #{message_id}")
 
@@ -157,12 +153,12 @@ module Flapjack
             message_id message_id
 
             text_part do
-              body text_template.result(bnd)
+              body body_text
             end
 
             html_part do
               content_type 'text/html; charset=UTF-8'
-              body html_template.result(bnd)
+              body body_html
             end
           end
 

data/lib/flapjack/gateways/email/alert.html.erb

@@ -11,7 +11,7 @@
   }
 </style>
 
-<p>Hi <%= @contact_first_name%></p>
+<p>Hi <%= @alert.contact_first_name%></p>
 
 <p>Monitoring has detected the following:</p>
 
@@ -19,56 +19,56 @@
   <tbody>
     <tr>
       <td><strong>Entity</strong></td>
-      <td><%= @entity_name %></td>
+      <td><%= @alert.entity %></td>
     </tr>
 
     <tr>
       <td><strong>Check</strong></td>
-      <td><%= @check %></td>
+      <td><%= @alert.check %></td>
     </tr>
 
     <tr>
       <td><strong>State</strong></td>
-      <td><%= ['ok'].include?(@state) ? @state.upcase : @state.titleize %></td>
+      <td><%= @alert.state_title_case %></td>
     </tr>
 
     <tr>
       <td><strong>Summary</strong></td>
-      <td><%= @summary %></td>
+      <td><%= @alert.summary %></td>
     </tr>
 
-    <% if @details %>
+    <% if @alert.details %>
       <tr>
         <td><strong>Details</strong></td>
-        <td><%= @details %></td>
+        <td><%= @alert.details %></td>
       </tr>
     <% end %>
 
-    <% if @time %>
+    <% if @alert.time %>
       <tr>
         <td><strong>Time</strong></td>
-        <td><%= Time.at(@time.to_i).to_s %></td>
+        <td><%= Time.at(@alert.time.to_i).to_s %></td>
       </tr>
     <% end %>
 
-    <% if @duration && @duration > 40 %>
+    <% if @alert.state_duration && @alert.state_duration > 40 %>
       <tr>
         <td><strong>Duration</strong></td>
-        <td><%= ChronicDuration.output(@duration) %></td>
+        <td><%= ChronicDuration.output(@alert.state_duration) %></td>
       </tr>
     <% end %>
 
-    <% if @last_state %>
+    <% if @alert.last_state %>
       <tr>
         <td><strong>Previous State</strong></td>
-        <td><%= ['ok'].include?(@last_state) ? @last_state.upcase : @last_state.titleize %></td>
+        <td><%= @alert.last_state_title_case %></td>
       </tr>
     <% end %>
 
-    <% if @last_summary %>
+    <% if @alert.last_summary %>
       <tr>
         <td><strong>Previous Summary</strong></td>
-        <td><%= @last_summary %></td>
+        <td><%= @alert.last_summary %></td>
       </tr>
     <% end %>