flapjack 0.7.18 → 0.7.19

data/lib/flapjack/data/contact.rb

@@ -235,10 +235,11 @@ module Flapjack
       end
 
       # drop notifications for
-      def drop_notifications?(opts)
+      def drop_notifications?(opts = {})
         media    = opts[:media]
         check    = opts[:check]
         state    = opts[:state]
+
         # build it and they will come
         @redis.exists("drop_alerts_for_contact:#{self.id}") ||
           (media && @redis.exists("drop_alerts_for_contact:#{self.id}:#{media}")) ||
@@ -248,7 +249,7 @@ module Flapjack
             @redis.exists("drop_alerts_for_contact:#{self.id}:#{media}:#{check}:#{state}"))
       end
 
-      def update_sent_alert_keys(opts)
+      def update_sent_alert_keys(opts = {})
         media  = opts[:media]
         check  = opts[:check]
         state  = opts[:state]

data/lib/flapjack/data/entity.rb

@@ -97,12 +97,12 @@ module Flapjack
 
       def self.find_all_with_checks(options)
         raise "Redis connection not set" unless redis = options[:redis]
-        redis.keys("check:*").map {|s| s.sub(/^check:/, '').split(':', 2).first }.to_set
+        redis.zrange("current_entities", 0, -1)
       end
 
       def self.find_all_with_failing_checks(options)
         raise "Redis connection not set" unless redis = options[:redis]
-        redis.zrange("failed_checks", 0, -1).map {|s| s.split(':', 2).first }.to_set
+        Flapjack::Data::EntityCheck.find_all_failing_by_entity(:redis => redis).keys
       end
 
       def contacts
@@ -119,7 +119,7 @@ module Flapjack
       end
 
       def check_list
-        @redis.keys("check:#{@name}:*").map {|k| k =~ /^check:#{@name}:(.+)$/; $1}
+        @redis.zrange("current_checks:#{@name}", 0, -1)        
       end
 
       def check_count

data/lib/flapjack/data/entity_check.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'yajl/json_gem'
+require 'oj'
 
 require 'flapjack/patches'
 
@@ -53,6 +53,67 @@ module Flapjack
         self.new(entity, check, :redis => redis)
       end
 
+      def self.find_all_for_entity_name(entity_name, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        redis.zrange("current_checks:#{entity_name}", 0, -1)
+      end
+
+      def self.find_all(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        self.conflate_to_keys(self.find_all_by_entity(:redis => redis))
+      end
+
+      def self.find_all_by_entity(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        d = {}
+        redis.zrange("current_entities", 0, -1).each {|entity|
+          d[entity] = redis.zrange("current_checks:#{entity}", 0, -1)
+        }
+        d
+      end
+
+      def self.count_all(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        redis.zrange("current_entities", 0, -1).inject(0) {|memo, entity|
+          memo + redis.zcount("current_checks:#{entity}", '-inf', '+inf')
+        }
+      end
+
+      def self.find_all_failing(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        self.conflate_to_keys(self.find_all_failing_by_entity(:redis => redis))
+      end
+
+      def self.find_all_failing_by_entity(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        redis.zrange("failed_checks", 0, -1).inject({}) do |memo, key|
+          entity, check = key.split(':', 2)
+          if !!redis.zscore("current_checks:#{entity}", check)
+            memo[entity] ||= []
+            memo[entity] << check
+          end
+          memo  
+        end
+      end
+
+      def self.count_all_failing(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        redis.zrange("failed_checks", 0, -1).count do |key|
+          entity, check = key.split(':', 2) 
+          !!redis.zscore("current_checks:#{entity}", check)
+        end
+      end
+
+      def self.conflate_to_keys(entity_checks_hash)
+        result = []
+        entity_checks_hash.each {|entity, checks|
+          checks.each {|check|
+            result << "#{entity}:#{check}"
+          }
+        }
+        result
+      end
+
       def entity_name
         entity.name
       end
@@ -69,7 +130,7 @@ module Flapjack
       end
 
       # return data about current maintenance (scheduled or unscheduled, as specified)
-      def current_maintenance(opts)
+      def current_maintenance(opts = {})
         sched = opts[:scheduled] ? 'scheduled' : 'unscheduled'
         ts = @redis.get("#{@key}:#{sched}_maintenance")
         return unless ts
@@ -79,14 +140,14 @@ module Flapjack
         }
       end
 
-      def create_unscheduled_maintenance(opts = {})
-        end_unscheduled_maintenance if in_unscheduled_maintenance?
+      def create_unscheduled_maintenance(start_time, duration, opts = {})
+        raise ArgumentError, 'start time must be provided as a Unix timestamp' unless start_time && start_time.is_a?(Integer)
+        raise ArgumentError, 'duration in seconds must be provided' unless duration && duration.is_a?(Integer) && (duration > 0)
 
-        start_time = opts[:start_time]  # unix timestamp
-        duration   = opts[:duration]    # seconds
         summary    = opts[:summary]
         time_remaining = (start_time + duration) - Time.now.to_i
         if time_remaining > 0
+          end_unscheduled_maintenance(start_time) if in_unscheduled_maintenance?
           @redis.setex("#{@key}:unscheduled_maintenance", time_remaining, start_time)
         end
         @redis.zadd("#{@key}:unscheduled_maintenances", duration, start_time)
@@ -96,19 +157,14 @@ module Flapjack
       end
 
       # ends any unscheduled maintenance
-      def end_unscheduled_maintenance(opts = {})
-        defaults = {
-          :end_time => Time.now.to_i
-        }
-        options  = defaults.merge(opts)
-        end_time = options[:end_time]
+      def end_unscheduled_maintenance(end_time)
+        raise ArgumentError, 'end time must be provided as a Unix timestamp' unless end_time && end_time.is_a?(Integer)
 
         if (um_start = @redis.get("#{@key}:unscheduled_maintenance"))
           duration = end_time - um_start.to_i
           @logger.debug("ending unscheduled downtime for #{@key} at #{Time.at(end_time).to_s}") if @logger
           @redis.del("#{@key}:unscheduled_maintenance")
-          @redis.zadd("#{@key}:unscheduled_maintenances", duration, um_start)
-          @redis.zadd("#{@key}:sorted_unscheduled_maintenance_timestamps", um_start, um_start)
+          @redis.zadd("#{@key}:unscheduled_maintenances", duration, um_start) # updates existing UM 'score'
         else
           @logger.debug("end_unscheduled_maintenance called for #{@key} but none found") if @logger
         end
@@ -118,10 +174,11 @@ module Flapjack
       # TODO: consider adding some validation to the data we're adding in here
       # eg start_time is a believable unix timestamp (not in the past and not too
       # far in the future), duration is within some bounds...
-      def create_scheduled_maintenance(opts = {})
-        start_time = opts[:start_time]  # unix timestamp
-        duration   = opts[:duration]    # seconds
-        summary    = opts[:summary]
+      def create_scheduled_maintenance(start_time, duration, opts = {})
+        raise ArgumentError, 'start time must be provided as a Unix timestamp' unless start_time && start_time.is_a?(Integer)
+        raise ArgumentError, 'duration in seconds must be provided' unless duration && duration.is_a?(Integer) && (duration > 0)
+
+        summary = opts[:summary]
         @redis.zadd("#{@key}:scheduled_maintenances", duration, start_time)
         @redis.set("#{@key}:#{start_time}:scheduled_maintenance:summary", summary)
 
@@ -131,6 +188,30 @@ module Flapjack
         update_current_scheduled_maintenance(:revalidate => true)
       end
 
+      # if not in scheduled maintenance, looks in scheduled maintenance list for a check to see if
+      # current state should be set to scheduled maintenance, and sets it as appropriate
+      def update_current_scheduled_maintenance(opts = {})
+        if opts[:revalidate]
+          @redis.del("#{@key}:scheduled_maintenance")
+        else
+          return if in_scheduled_maintenance?
+        end
+
+        # are we within a scheduled maintenance period?
+        current_time = Time.now.to_i
+        current_sched_ms = maintenances(nil, nil, :scheduled => true).select {|sm|
+          (sm[:start_time] <= current_time) && (current_time < sm[:end_time])
+        }
+        return if current_sched_ms.empty?
+
+        # yes! so set current scheduled maintenance
+        # if multiple scheduled maintenances found, find the end_time furthest in the future
+        most_futuristic = current_sched_ms.max {|sm| sm[:end_time] }
+        start_time = most_futuristic[:start_time]
+        duration   = most_futuristic[:duration]
+        @redis.setex("#{@key}:scheduled_maintenance", duration.to_i, start_time)
+      end
+
       # TODO allow summary to be changed as part of the termination
       def end_scheduled_maintenance(start_time)
         raise ArgumentError, 'start time must be supplied as a Unix timestamp' unless start_time && start_time.is_a?(Integer)
@@ -162,32 +243,8 @@ module Flapjack
 
           return true
         end
-          
-        false
-      end
 
-      # if not in scheduled maintenance, looks in scheduled maintenance list for a check to see if
-      # current state should be set to scheduled maintenance, and sets it as appropriate
-      def update_current_scheduled_maintenance(opts = {})
-        if opts[:revalidate]
-          @redis.del("#{@key}:scheduled_maintenance")
-        else
-          return if in_scheduled_maintenance?
-        end
-
-        # are we within a scheduled maintenance period?
-        current_time = Time.now.to_i
-        current_sched_ms = maintenances(nil, nil, :scheduled => true).select {|sm|
-          (sm[:start_time] <= current_time) && (current_time < sm[:end_time])
-        }
-        return if current_sched_ms.empty?
-
-        # yes! so set current scheduled maintenance
-        # if multiple scheduled maintenances found, find the end_time furthest in the future
-        most_futuristic = current_sched_ms.max {|sm| sm[:end_time] }
-        start_time = most_futuristic[:start_time]
-        duration   = most_futuristic[:duration]
-        @redis.setex("#{@key}:scheduled_maintenance", duration.to_i, start_time)
+        false
       end
 
       # returns nil if no previous state; this must be considered as a possible
@@ -248,6 +305,22 @@ module Flapjack
 
       def last_update=(timestamp)
         @redis.hset("check:#{@key}", 'last_update', timestamp)
+        @redis.zadd("current_checks:#{entity.name}", timestamp, check)
+        @redis.zadd("current_entities", timestamp, entity.name)
+      end
+
+      # disables a check (removes currency)
+      def disable!
+        @logger.debug("disabling check [#{@key}]") if @logger
+        @redis.zrem("current_checks:#{entity.name}", check)
+        if @redis.zcount("current_checks:#{entity.name}", '-inf', '+inf') == 0
+          @redis.zrem("current_checks:#{entity.name}", check)
+          @redis.zrem("current_entities", entity.name)
+        end
+      end
+
+      def enabled?
+        !! @redis.zscore("current_checks:#{entity.name}", check)
       end
 
       def last_change

data/lib/flapjack/data/event.rb

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
 
-require 'yajl/json_gem'
+require 'oj'
 
 module Flapjack
   module Data
     class Event
 
-      attr_accessor :previous_state, :previous_state_duration
+      attr_accessor :counter, :previous_state, :previous_state_duration
 
       attr_reader :check, :summary, :details, :acknowledgement_id
 
@@ -20,7 +20,7 @@ module Flapjack
       # Calling next with :block => false, will return a nil if there are no
       # events on the queue.
       #
-      def self.next(opts={})
+      def self.next(queue, opts = {})
         raise "Redis connection not set" unless redis = opts[:redis]
 
         defaults = { :block => true,
@@ -31,23 +31,23 @@ module Flapjack
         if options[:archive_events]
           dest = "events_archive:#{Time.now.utc.strftime "%Y%m%d%H"}"
           if options[:block]
-            raw = redis.brpoplpush('events', dest, 0)
+            raw = redis.brpoplpush(queue, dest, 0)
           else
-            raw = redis.rpoplpush('events', dest)
+            raw = redis.rpoplpush(queue, dest)
             return unless raw
           end
           redis.expire(dest, options[:events_archive_maxage])
         else
           if options[:block]
-            raw = redis.brpop('events', 0)[1]
+            raw = redis.brpop(queue, 0)[1]
           else
-            raw = redis.rpop('events')
+            raw = redis.rpop(queue)
             return unless raw
           end
         end
         begin
-          parsed = ::JSON.parse( raw )
-        rescue => e
+          parsed = ::Oj.load( raw )
+        rescue Oj::Error => e
           if options[:logger]
             options[:logger].warn("Error deserialising event json: #{e}, raw json: #{raw.inspect}")
           end
@@ -65,7 +65,7 @@ module Flapjack
         raise "Redis connection not set" unless redis = opts[:redis]
 
         evt['time'] = Time.now.to_i if evt['time'].nil?
-        redis.rpush('events', ::Yajl::Encoder.encode(evt))
+        redis.rpush('events', ::Oj.dump(evt))
       end
 
       # Provide a count of the number of events on the queue to be processed.

data/lib/flapjack/data/message.rb

@@ -5,7 +5,6 @@
 # contact+media recipient.
 
 require 'flapjack/data/contact'
-require 'flapjack/data/notification'
 
 module Flapjack
   module Data
@@ -15,8 +14,8 @@ module Flapjack
 
       def self.for_contact(contact, opts = {})
         self.new(:contact => contact,
-                 :notification_contents => opts[:notification_contents],
-                 :medium => opts[:medium], :address => opts[:address],
+                 :medium => opts[:medium],
+                 :address => opts[:address],
                  :duration => opts[:duration])
       end
 
@@ -36,15 +35,13 @@ module Flapjack
              'contact_first_name' => contact.first_name,
              'contact_last_name'  => contact.last_name}
         c['duration'] = duration if duration
-        return c if @notification_contents.nil?
-        c.merge(@notification_contents)
+        c
       end
 
     private
 
       def initialize(opts = {})
         @contact = opts[:contact]
-        @notification_contents = opts[:notification_contents]
         @medium = opts[:medium]
         @address = opts[:address]
         @duration = opts[:duration]

data/lib/flapjack/data/notification.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'oj'
+
 require 'flapjack/data/contact'
 require 'flapjack/data/event'
 require 'flapjack/data/message'
@@ -8,52 +10,110 @@ module Flapjack
   module Data
     class Notification
 
-      attr_reader :event, :type, :max_notified_severity, :contacts,
-        :default_timezone, :last_state
-
-      def self.for_event(event, opts = {})
-        self.new(:event => event,
-                 :type => opts[:type],
-                 :max_notified_severity => opts[:max_notified_severity],
-                 :contacts => opts[:contacts],
-                 :default_timezone => opts[:default_timezone],
-                 :last_state => opts[:last_state],
-                 :logger => opts[:logger])
-      end
-
-      def messages
-        return [] if contacts.nil? || contacts.empty?
+      attr_reader :type, :event_id, :event_state, :event_count
 
-        event_id = event.id
-        event_state = event.state
+      def self.type_for_event(event)
+        case event.type
+        when 'service'
+          case event.state
+          when 'ok'
+            'recovery'
+          when 'warning', 'critical', 'unknown'
+            'problem'
+          end
+        when 'action'
+          case event.state
+          when 'acknowledgement'
+            'acknowledgement'
+          when 'test_notifications'
+            'test'
+          end
+        else
+          'unknown'
+        end
+      end
 
-        severity = if ([event_state, max_notified_severity] & ['critical', 'unknown', 'test_notifications']).any?
+      def self.severity_for_event(event, max_notified_severity)
+        if ([event.state, max_notified_severity] & ['critical', 'unknown', 'test_notifications']).any?
           'critical'
-        elsif [event_state, max_notified_severity].include?('warning')
+        elsif [event.state, max_notified_severity].include?('warning')
           'warning'
         else
           'ok'
         end
+      end
+
+      def self.add(queue, event, opts = {})
+        raise "Redis connection not set" unless redis = opts[:redis]
+
+        last_state = opts[:last_state] || {}
+
+        notif = {'event_id'     => event.id,
+                 'state'        => event.state,
+                 'summary'      => event.summary,
+                 'last_state'   => last_state[:state],
+                 'last_summary' => last_state[:summary],
+                 'details'      => event.details,
+                 'time'         => event.time,
+                 'duration'     => event.duration || nil,
+                 'type'         => opts[:type] || type_for_event(event),
+                 'severity'     => opts[:severity],
+                 'count'        => event.counter }
+
+        redis.rpush(queue, Oj.dump(notif))
+      end
+
+      def self.next(queue, opts = {})
+        raise "Redis connection not set" unless redis = opts[:redis]
+
+        defaults = { :block => true }
+        options  = defaults.merge(opts)
+
+        if options[:block]
+          raw = redis.blpop(queue, 0)[1]
+        else
+          raw = redis.lpop(queue)
+          return unless raw
+        end
+        begin
+          parsed = ::Oj.load( raw )
+        rescue Oj::Error => e
+          if options[:logger]
+            options[:logger].warn("Error deserialising notification json: #{e}, raw json: #{raw.inspect}")
+          end
+          return nil
+        end
+        self.new( parsed )
+      end
+
+      def contents
+        @contents ||= {'event_id'          => @event_id,
+                       'state'             => @event_state,
+                       'summary'           => @event_summary,
+                       'last_state'        => @last_event_state,
+                       'last_summary'      => @last_event_summary,
+                       'details'           => @event_details,
+                       'time'              => @event_time,
+                       'duration'          => @event_duration,
+                       'notification_type' => @type,
+                       'event_count'       => @event_count
+                      }
+      end
+
+      def messages(contacts, opts = {})
+        return [] if contacts.nil? || contacts.empty?
 
-        contents = {'event_id'              => event_id,
-                    'state'                 => event_state,
-                    'summary'               => event.summary,
-                    'last_state'            => @last_state ? @last_state[:state] : nil,
-                    'last_summary'          => @last_state ? @last_state[:summary] : nil,
-                    'details'               => event.details,
-                    'time'                  => event.time,
-                    'duration'              => event.duration || nil,
-                    'notification_type'     => type,
-                    'max_notified_severity' => max_notified_severity }
+        default_timezone = opts[:default_timezone]
+        logger = opts[:logger]
 
         @messages ||= contacts.collect {|contact|
           contact_id = contact.id
           rules = contact.notification_rules
           media = contact.media
 
-          @logger.debug "considering messages for contact id #{contact_id} #{event_id} #{event_state} (media) #{media.inspect}"
+          logger.debug "considering messages for contact id #{contact_id} #{@event_id} #{@event_state} (media) #{media.inspect}"
           rlen = rules.length
-          @logger.debug "found #{rlen} rule#{(rlen == 1) ? '' : 's'} for contact"
+          logger.debug "found #{rlen} rule#{(rlen == 1) ? '' : 's'} for contact"
 
           media_to_use = if rules.empty?
             media
@@ -61,55 +121,54 @@ module Flapjack
             # matchers are rules of the contact that have matched the current event
             # for time and entity
             matchers = rules.select do |rule|
-              rule.match_entity?(event_id) &&
+              rule.match_entity?(@event_id) &&
                 rule_occurring_now?(rule, :contact => contact, :default_timezone => default_timezone)
             end
 
-            @logger.debug "#{matchers.length} matchers remain for this contact:"
+            logger.debug "#{matchers.length} matchers remain for this contact:"
             matchers.each do |matcher|
-              @logger.debug "matcher: #{matcher.to_json}"
+              logger.debug "matcher: #{matcher.to_json}"
             end
 
             # delete any matchers for all entities if there are more specific matchers
             if matchers.any? {|matcher| matcher.is_specific? }
 
-              @logger.debug("general removal: found #{matchers.length} entity specific matchers")
+              logger.debug("general removal: found #{matchers.length} entity specific matchers")
               num_matchers = matchers.length
 
               matchers.reject! {|matcher| !matcher.is_specific? }
 
               if num_matchers != matchers.length
-                @logger.debug("notification: removal of general matchers when entity specific matchers are present: number of matchers changed from #{num_matchers} to #{matchers.length} for contact id: #{contact_id}")
+                logger.debug("notification: removal of general matchers when entity specific matchers are present: number of matchers changed from #{num_matchers} to #{matchers.length} for contact id: #{contact_id}")
               end
             end
 
             # delete media based on blackholes
-            next if matchers.any? {|matcher| matcher.blackhole?(event_state) }
+            next if matchers.any? {|matcher| matcher.blackhole?(@event_state) }
 
-            @logger.debug "notification: num matchers after removing blackhole matchers: #{matchers.size}"
+            logger.debug "notification: num matchers after removing blackhole matchers: #{matchers.size}"
 
             rule_media = matchers.collect{|matcher|
-              matcher.media_for_severity(severity)
+              matcher.media_for_severity(@severity)
             }.flatten.uniq
 
-            @logger.debug "notification: collected media_for_severity(#{severity}): #{rule_media}"
-            rule_media = rule_media.flatten.uniq.reject {|medium|
+            logger.debug "notification: collected media_for_severity(#{@severity}): #{rule_media}"
+            rule_media = rule_media.reject {|medium|
               contact.drop_notifications?(:media => medium,
-                                          :check => event_id,
-                                          :state => event_state)
+                                          :check => @event_id,
+                                          :state => @event_state)
             }
 
-            @logger.debug "notification: media after contact_drop?: #{rule_media}"
+            logger.debug "notification: media after contact_drop?: #{rule_media}"
 
             media.select {|medium, address| rule_media.include?(medium) }
           end
 
-          @logger.debug "notification: media_to_use: #{media_to_use}"
+          logger.debug "notification: media_to_use: #{media_to_use}"
 
           media_to_use.each_pair.inject([]) { |ret, (k, v)|
             m = Flapjack::Data::Message.for_contact(contact,
-              :notification_contents => contents,
-              :medium => k, :address => v)
+                  :medium => k, :address => v)
             ret << m
             ret
           }
@@ -118,15 +177,21 @@ module Flapjack
 
     private
 
+      # created from parsed JSON, so opts keys are in strings
       def initialize(opts = {})
-        raise "Event not passed" unless event = opts[:event]
-        @event = event
-        @type  = opts[:type]
-        @max_notified_severity = opts[:max_notified_severity]
-        @contacts = opts[:contacts]
-        @default_timezone = opts[:default_timezone]
-        @last_state = opts[:last_state]
-        @logger = opts[:logger]
+        @event_id       = opts['event_id']
+        @event_state    = opts['state']
+        @event_summary  = opts['summary']
+        @event_details  = opts['details']
+        @event_time     = opts['time']
+        @event_duration = opts['duration']
+        @event_count    = opts['count']
+
+        @last_event_state   = opts['last_state']
+        @last_event_summary = opts['last_summary']
+
+        @type           = opts['type']
+        @severity       = opts['severity']
       end
 
       # # time restrictions match?
@@ -135,11 +200,11 @@ module Flapjack
       # considered to be in the timezone of the contact
       def rule_occurring_now?(rule, options = {})
         contact = options[:contact]
-        default_timezone = options[:default_timezone]
+        def_tz = options[:default_timezone]
 
         return true if rule.time_restrictions.nil? or rule.time_restrictions.empty?
 
-        timezone = contact.timezone(:default => default_timezone)
+        timezone = contact.timezone(:default => def_tz)
         usertime = timezone.now
 
         rule.time_restrictions.any? do |tr|