flapjack 1.2.0rc2 → 1.2.0

data/lib/flapjack/data/entity_check.rb

@@ -163,16 +163,6 @@ module Flapjack
         }
       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 self.find_maintenance(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         type = options[:type]
@@ -619,57 +609,54 @@ module Flapjack
 
         old_state = self.state
 
-        @redis.multi
+        @redis.multi do |multi|
 
-        if old_state != new_state
+          if old_state != new_state
 
-          # Note the current state (for speedy lookups)
-          @redis.hset("check:#{@key}", 'state', new_state)
+            # Note the current state (for speedy lookups)
+            multi.hset("check:#{@key}", 'state', new_state)
 
-          # FIXME: rename to last_state_change?
-          @redis.hset("check:#{@key}", 'last_change', timestamp)
+            # FIXME: rename to last_state_change?
+            multi.hset("check:#{@key}", 'last_change', timestamp)
 
-          case new_state
-          when STATE_WARNING, STATE_CRITICAL, STATE_UNKNOWN
-            @redis.zadd('failed_checks', timestamp, @key)
-            # FIXME: Iterate through a list of tags associated with an entity:check pair, and update counters
-          else
-            @redis.zrem("failed_checks", @key)
-            # FIXME: Iterate through a list of tags associated with an entity:check pair, and update counters
-          end
+            case new_state
+            when STATE_WARNING, STATE_CRITICAL, STATE_UNKNOWN
+              multi.zadd('failed_checks', timestamp, @key)
+              # FIXME: Iterate through a list of tags associated with an entity:check pair, and update counters
+            else
+              multi.zrem("failed_checks", @key)
+              # FIXME: Iterate through a list of tags associated with an entity:check pair, and update counters
+            end
 
-          # Retain event data for entity:check pair
-          # NB (appending to tail as far as Redis is concerned)
-          @redis.rpush("#{@key}:states", timestamp)
-          @redis.set("#{@key}:#{timestamp}:state", new_state)
-          @redis.set("#{@key}:#{timestamp}:summary", summary) if summary
-          @redis.set("#{@key}:#{timestamp}:details", details) if details
-          @redis.set("#{@key}:#{timestamp}:count", count) if count
+            # Retain event data for entity:check pair
+            # NB (appending to tail as far as Redis is concerned)
+            multi.rpush("#{@key}:states", timestamp)
+            multi.set("#{@key}:#{timestamp}:state", new_state)
+            multi.set("#{@key}:#{timestamp}:summary", summary) if summary
+            multi.set("#{@key}:#{timestamp}:details", details) if details
+            multi.set("#{@key}:#{timestamp}:count", count) if count
 
-          @redis.zadd("#{@key}:sorted_state_timestamps", timestamp, timestamp)
-        end
+            multi.zadd("#{@key}:sorted_state_timestamps", timestamp, timestamp)
+          end
 
-        # Track when we last saw an event for a particular entity:check pair
-        self.last_update = timestamp
+          # Track when we last saw an event for a particular entity:check pair
+          # (used to be last_update=, but needs to happen in the multi block)
+          multi.hset("check:#{@key}", 'last_update', timestamp)
+          multi.zadd("all_checks", timestamp, @key)
+          multi.zadd("all_checks:#{entity.name}", timestamp, check)
+          multi.zadd("current_checks:#{entity.name}", timestamp, check)
+          multi.zadd('current_entities', timestamp, entity.name)
+
+          # Even if this isn't a state change, we need to update the current state
+          # hash summary and details (as they may have changed)
+          multi.hset("check:#{@key}", 'summary', (summary || ''))
+          multi.hset("check:#{@key}", 'details', (details || ''))
+          if perfdata
+            multi.hset("check:#{@key}", 'perfdata', format_perfdata(perfdata).to_json)
+  #          multi.set("#{@key}:#{timestamp}:perfdata", perfdata)
+          end
 
-        # Even if this isn't a state change, we need to update the current state
-        # hash summary and details (as they may have changed)
-        @redis.hset("check:#{@key}", 'summary', (summary || ''))
-        @redis.hset("check:#{@key}", 'details', (details || ''))
-        if perfdata
-          @redis.hset("check:#{@key}", 'perfdata', format_perfdata(perfdata).to_json)
-#          @redis.set("#{@key}:#{timestamp}:perfdata", perfdata)
         end
-
-        @redis.exec
-      end
-
-      def last_update=(timestamp)
-        @redis.hset("check:#{@key}", 'last_update', timestamp)
-        @redis.zadd("all_checks", timestamp, @key)
-        @redis.zadd("all_checks:#{entity.name}", timestamp, check)
-        @redis.zadd("current_checks:#{entity.name}", timestamp, check)
-        @redis.zadd('current_entities', timestamp, entity.name)
       end
 
       def last_update
@@ -1007,6 +994,13 @@ module Flapjack
         @logger = options[:logger]
       end
 
+      def self.conflate_to_keys(entity_checks_hash)
+        entity_checks_hash.inject([]) {|memo, (entity, checks)|
+          memo += checks.collect {|check| "#{entity}:#{check}" }
+          memo
+        }
+      end
+
       def format_perfdata(perfdata)
         # example perfdata: time=0.486630s;;;0.000000 size=909B;;;0
         items = perfdata.split(' ')

data/lib/flapjack/data/event.rb

@@ -107,10 +107,10 @@ module Flapjack
           # store the raw data in a rejected list
           rejected_dest = "events_rejected:#{base_time_str}"
           if options[:archive_events]
-            redis.multi
-            redis.lrem(archive_dest, 1, raw)
-            redis.lpush(rejected_dest, raw)
-            redis.exec
+            redis.multi do |multi|
+              multi.lrem(archive_dest, 1, raw)
+              multi.lpush(rejected_dest, raw)
+            end
             redis.expire(archive_dest, options[:events_archive_maxage])
           else
             redis.lpush(rejected_dest, raw)

data/lib/flapjack/data/migration.rb

@@ -1,5 +1,8 @@
 #!/usr/bin/env ruby
 
+require 'flapjack/data/contact'
+require 'flapjack/data/entity_check'
+
 require 'flapjack/data/semaphore'
 
 module Flapjack
@@ -116,6 +119,32 @@ module Flapjack
         end
       end
 
+      def self.correct_notification_rule_contact_linkages(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+
+        logger = options[:logger]
+
+        if redis.exists('corrected_notification_rule_contact_linkages')
+          return
+        end
+
+        invalid_notification_rule_keys = redis.keys("notification_rule:*").select {|k|
+          contact_id = redis.hget(k, 'contact_id')
+          contact_id.nil? || contact_id.empty?
+        }.collect {|nrk| nrk.sub(/^notification_rule:/, '') }
+
+        unless invalid_notification_rule_keys.empty?
+          Flapjack::Data::Contact.all(:redis => redis).each do |contact|
+            correctable = contact.notification_rule_ids & invalid_notification_rule_keys
+            next if correctable.empty?
+            correctable.each {|ck| redis.hset("notification_rule:#{ck}", 'contact_id', contact.id) }
+            logger.warn "Set contact #{contact.id} for rules #{correctable.join(', ')}" unless logger.nil?
+          end
+        end
+
+        redis.set('corrected_notification_rule_contact_linkages', 'true')
+      end
+
     end
   end
 end

data/lib/flapjack/gateways/jsonapi.rb

@@ -229,7 +229,7 @@ module Flapjack
                          (request.query_string.length > 0)) ? "?#{request.query_string}" : ""
         if logger.debug?
           input = env['rack.input'].read
-          logger.debug("#{request.request_method} #{request.path_info}#{query_string} #{input}")
+          logger.debug("#{request.request_method} #{request.path_info}#{query_string} Headers: #{headers.inspect}, Body: #{input}")
         elsif logger.info?
           input = env['rack.input'].read
           input_short = input.gsub(/\n/, '').gsub(/\s+/, ' ')
@@ -250,8 +250,9 @@ module Flapjack
           else
             response.body.to_s
           end
+          headers_debug = response.headers.to_s
           logger.debug("Returning #{response.status} for #{request.request_method} " +
-            "#{request.path_info}#{query_string}, body: #{body_debug}")
+            "#{request.path_info}#{query_string}, headers: #{headers_debug}, body: #{body_debug}")
         elsif logger.info?
           logger.info("Returning #{response.status} for #{request.request_method} " +
             "#{request.path_info}#{query_string}")

data/lib/flapjack/gateways/jsonapi/report_methods.rb

@@ -27,11 +27,18 @@ module Flapjack
             end
 
             checks = if event_ids.nil?
-              Flapjack::Data::EntityCheck.find_current_names(:redis => redis).collect {|check_name|
-                find_entity_check_by_name(*check_name.split(':', 2))
-              }
+              Flapjack::Data::EntityCheck.find_current_names(:redis => redis).
+                each_with_object([]) do |check_name, memo|
+                  en, cn = check_name.split(':', 2)
+                  halt(500, 'Malformed check ID') if en.nil? || cn.nil?
+                  memo << find_entity_check_by_name(en, cn)
+                end
             elsif !event_ids.empty?
-              event_ids.collect {|event_id| find_entity_check_by_name(*event_id.split(':', 2)) }
+              event_ids.each_with_object([]) do |event_id, memo|
+                en, cn = event_id.split(':', 2)
+                halt(500, 'Malformed check ID') if en.nil? || cn.nil?
+                memo << find_entity_check_by_name(en, cn)
+              end
             else
               nil
             end

data/lib/flapjack/gateways/web.rb

@@ -57,7 +57,7 @@ module Flapjack
 
           @api_url = @config['api_url']
           if @api_url
-            if (@api_url =~ /^#{URI::regexp(%w(http https))}$/).nil?
+            if URI.regexp(['http', 'https']).match(@api_url).nil?
               @logger.error "api_url is not a valid http or https URI (#{@api_url}), discarding"
               @api_url = nil
             end

data/lib/flapjack/notifier.rb

@@ -90,7 +90,8 @@ module Flapjack
 
       timestamp    = Time.now
       event_id     = notification.event_id
-      entity_check = Flapjack::Data::EntityCheck.for_event_id(event_id, :redis => @redis, :logger => @logger)
+      entity_check = Flapjack::Data::EntityCheck.for_event_id(event_id,
+                      :redis => @redis, :logger => @logger)
       contacts     = entity_check.contacts
 
       if contacts.empty?
@@ -99,14 +100,11 @@ module Flapjack
         return
       end
 
-      messages = notification.messages(contacts, :default_timezone => @default_contact_timezone,
-        :logger => @logger)
+      messages = notification.messages(contacts,
+        :default_timezone => @default_contact_timezone, :logger => @logger)
 
       notification_contents = notification.contents
 
-      in_unscheduled_maintenance = entity_check.in_scheduled_maintenance?
-      in_scheduled_maintenance   = entity_check.in_unscheduled_maintenance?
-
       messages.each do |message|
         media_type = message.medium
         address    = message.address
@@ -123,9 +121,7 @@ module Flapjack
             memo
           end
           contents['rollup_alerts'] = rollup_alerts
-
           contents['rollup_threshold'] = message.contact.rollup_threshold_for_media(media_type)
-
         end
 
         @notifylog.info("#{event_id} | " +

data/lib/flapjack/processor.rb

@@ -191,19 +191,19 @@ module Flapjack
           event.id_hash = entity_check.ack_hash
         end
 
-        @redis.multi
-        if event.ok?
-          @redis.hincrby('event_counters', 'ok', 1)
-          @redis.hincrby("event_counters:#{@instance_id}", 'ok', 1)
-        elsif event.failure?
-          @redis.hincrby('event_counters', 'failure', 1)
-          @redis.hincrby("event_counters:#{@instance_id}", 'failure', 1)
-        else
-          @redis.hincrby('event_counters', 'invalid', 1)
-          @redis.hincrby("event_counters:#{@instance_id}", 'invalid', 1)
-          @logger.error("Invalid event received: #{event.inspect}")
+        @redis.multi do |multi|
+          if event.ok?
+            multi.hincrby('event_counters', 'ok', 1)
+            multi.hincrby("event_counters:#{@instance_id}", 'ok', 1)
+          elsif event.failure?
+            multi.hincrby('event_counters', 'failure', 1)
+            multi.hincrby("event_counters:#{@instance_id}", 'failure', 1)
+          else
+            multi.hincrby('event_counters', 'invalid', 1)
+            multi.hincrby("event_counters:#{@instance_id}", 'invalid', 1)
+            @logger.error("Invalid event received: #{event.inspect}")
+          end
         end
-        @redis.exec
 
         previous_state = entity_check.state
 
@@ -233,14 +233,16 @@ module Flapjack
       # Action events represent human or automated interaction with Flapjack
       when 'action'
         # When an action event is processed, store the event.
-        @redis.multi
-        @redis.hset(event.id + ':actions', timestamp, event.state)
-        @redis.hincrby('event_counters', 'action', 1)
-        @redis.hincrby("event_counters:#{@instance_id}", 'action', 1)
-        @redis.exec
+        @redis.multi do |multi|
+          multi.hset(event.id + ':actions', timestamp, event.state)
+          multi.hincrby('event_counters', 'action', 1)
+          multi.hincrby("event_counters:#{@instance_id}", 'action', 1)
+        end
       else
-        @redis.hincrby('event_counters', 'invalid', 1)
-        @redis.hincrby("event_counters:#{@instance_id}", 'invalid', 1)
+        @redis.multi do |multi|
+          multi.hincrby('event_counters', 'invalid', 1)
+          multi.hincrby("event_counters:#{@instance_id}", 'invalid', 1)
+        end
         @logger.error("Invalid event received: #{event.inspect}")
       end
 
@@ -251,12 +253,12 @@ module Flapjack
       notification_type = Flapjack::Data::Notification.type_for_event(event)
       max_notified_severity = entity_check.max_notified_severity_of_current_failure
 
-      @redis.multi
-      @redis.set("#{event.id}:last_#{notification_type}_notification", timestamp)
-      @redis.set("#{event.id}:last_#{event.state}_notification", timestamp) if event.failure?
-      @redis.rpush("#{event.id}:#{notification_type}_notifications", timestamp)
-      @redis.rpush("#{event.id}:#{event.state}_notifications", timestamp) if event.failure?
-      @redis.exec
+      @redis.multi do |multi|
+        multi.set("#{event.id}:last_#{notification_type}_notification", timestamp)
+        multi.set("#{event.id}:last_#{event.state}_notification", timestamp) if event.failure?
+        multi.rpush("#{event.id}:#{notification_type}_notifications", timestamp)
+        multi.rpush("#{event.id}:#{event.state}_notifications", timestamp) if event.failure?
+      end
 
       @logger.debug("Notification of type #{notification_type} is being generated for #{event.id}: " + event.inspect)
 

data/lib/flapjack/redis_pool.rb

@@ -21,6 +21,8 @@ module Flapjack
       logger = opts[:logger]
       super(:size => @size) {
         redis = ::Redis.new(config)
+        Flapjack::Data::Migration.correct_notification_rule_contact_linkages(:redis => redis,
+          :logger => logger)
         Flapjack::Data::Migration.migrate_entity_check_data_if_required(:redis => redis,
           :logger => logger)
         Flapjack::Data::Migration.refresh_archive_index(:redis => redis)

data/lib/flapjack/version.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "1.2.0rc2"
+  VERSION = "1.2.0"
 end
 

data/spec/lib/flapjack/data/contact_spec.rb

@@ -218,7 +218,12 @@ describe Flapjack::Data::Contact, :redis => true do
     ec = Flapjack::Data::EntityCheck.for_entity_name(entity_name, 'PING', :redis => @redis)
     t = Time.now.to_i
     ec.update_state('ok', :timestamp => t, :summary => 'a')
-    ec.last_update = t
+    # was check.last_update=
+    @redis.hset("check:#{entity_name}:PING", 'last_update', t)
+    @redis.zadd("all_checks", t, @key)
+    @redis.zadd("all_checks:#{entity_name}", t, 'PING')
+    @redis.zadd("current_checks:#{entity_name}", t, 'PING')
+    @redis.zadd('current_entities', t, entity_name)
 
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     eandcs = contact.entities(:checks => true)

data/spec/lib/flapjack/data/entity_check_spec.rb

@@ -1199,7 +1199,13 @@ describe Flapjack::Data::EntityCheck, :redis => true do
   it "updates enabled checks" do
     ts = Time.now.to_i
     ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    ec.last_update = ts
+
+    # was check.last_update=
+    @redis.hset("check:#{name}:#{check}", 'last_update', ts)
+    @redis.zadd("all_checks", ts, @key)
+    @redis.zadd("all_checks:#{name}", ts, check)
+    @redis.zadd("current_checks:#{name}", ts, check)
+    @redis.zadd('current_entities', ts, name)
 
     saved_check_ts = @redis.zscore("current_checks:#{name}", check)
     expect(saved_check_ts).not_to be_nil

data/spec/lib/flapjack/data/event_spec.rb

@@ -6,6 +6,7 @@ describe Flapjack::Data::Event do
   let(:entity_name) { 'xyz-example.com' }
   let(:check)       { 'ping' }
   let(:redis)       { double(::Redis) }
+  let(:multi)       { double('multi') }
 
   let!(:time) { Time.now}
 
@@ -79,10 +80,9 @@ describe Flapjack::Data::Event do
       expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
       expect(redis).to receive(:sadd).
         with('known_events_archive_keys', /^events_archive:/)
-      expect(redis).to receive(:multi)
-      expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-      expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-      expect(redis).to receive(:exec)
+      expect(redis).to receive(:multi).and_yield(multi)
+      expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+      expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
       expect(redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => true,
@@ -112,10 +112,9 @@ describe Flapjack::Data::Event do
         expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
         expect(redis).to receive(:sadd).
           with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi)
-        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:exec)
+        expect(redis).to receive(:multi).and_yield(multi)
+        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
         expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
@@ -145,10 +144,9 @@ describe Flapjack::Data::Event do
         expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
         expect(redis).to receive(:sadd).
           with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi)
-        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:exec)
+        expect(redis).to receive(:multi).and_yield(multi)
+        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
         expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
@@ -180,10 +178,9 @@ describe Flapjack::Data::Event do
         expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
         expect(redis).to receive(:sadd).
           with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi)
-        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:exec)
+        expect(redis).to receive(:multi).and_yield(multi)
+        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
         expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
@@ -271,10 +268,9 @@ describe Flapjack::Data::Event do
         expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
         expect(redis).to receive(:sadd).
           with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi)
-        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:exec)
+        expect(redis).to receive(:multi).and_yield(multi)
+        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
         expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,