flapjack 1.2.0rc1 → 1.2.0rc2

data/lib/flapjack/data/entity_check.rb

@@ -47,10 +47,12 @@ module Flapjack
         logger = options[:logger]
         timestamp = Time.now.to_i
 
-        redis.zadd("current_checks:#{ent.name}", timestamp, check_name)
-        redis.zadd('current_entities', timestamp, ent.name)
+        entity_name = ent.name
 
-        c = self.new(ent, check_name, :logger  => logger,
+        redis.zadd("current_checks:#{entity_name}", timestamp, check_name)
+        redis.zadd('current_entities', timestamp, entity_name)
+
+        c = self.new(ent, check_name, :logger => logger, :timestamp => timestamp,
                      :redis => redis)
         if check_data['tags'] && check_data['tags'].respond_to?(:each)
           c.add_tags(*check_data['tags'])
@@ -95,17 +97,9 @@ module Flapjack
 
       def self.all(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        checks = redis.keys('check:*').map {|c| c.match(/^check:(.+)$/) ; $1} |
-                   find_current_names(:redis => redis)
-        checks.map {|ec|
-          self.for_event_id(ec, options)
-        }
-      end
-
-      def self.find_all_names_for_entity_name(entity_name, options = {})
-        raise "Redis connection not set" unless redis = options[:redis]
-        en = Regexp.escape(entity_name)
-        redis.keys('check:*').map {|c| c.match(/^check:#{en}:(.+)$/); $1}
+        redis.zrange("all_checks", 0, -1).collect do |cname|
+          self.for_event_id(cname, options)
+        end
       end
 
       def self.find_current_names_for_entity_name(entity_name, options = {})
@@ -182,36 +176,42 @@ module Flapjack
       def self.find_maintenance(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         type = options[:type]
-        keys = redis.keys("*:#{type}_maintenances")
-        keys.flat_map { |k|
-          entity = k.split(':')[0]
-          check = k.split(':')[1]
+
+        checks_with_maints = redis.zrange("all_checks", 0, -1).select do |ec_name|
+          # not ideal, but redis internals should essentially make this a lot
+          # of separate hash lookups
+          redis.exists("#{ec_name}:#{type}_maintenances")
+        end
+
+        return [] if checks_with_maints.empty?
+
+        entity_re = options[:entity].nil? ? nil : Regexp.new(options[:entity])
+        check_re  = options[:check].nil?  ? nil : Regexp.new(options[:check])
+        reason_re = options[:reason].nil? ? nil : Regexp.new(options[:reason])
+
+        checks_with_maints.inject([]) do |memo, k|
+          entity, check = k.split(':', 2)
           ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => redis)
 
           # Only return entries which match what was passed in
-          case
-          when options[:state] && options[:state] != ec.state
-            nil
-          when options[:entity] && !Regexp.new(options[:entity]).match(entity)
-            nil
-          when options[:check] && !Regexp.new(options[:check]).match(check)
-            nil
-          else
-            windows = ec.maintenances(nil, nil, type.to_sym => true)
-            windows.map { |window|
-              entry = { :entity => entity,
-                        :check => check,
-                        :state => ec.state
-              }
-              if (options[:reason].nil? || Regexp.new(options[:reason]).match(window[:summary])) &&
-                check_maintenance_timestamp(options[:started], window[:start_time]) &&
-                check_maintenance_timestamp(options[:finishing], window[:end_time]) &&
-                check_maintenance_interval(options[:duration], window[:duration])
-                entry.merge!(window)
-              end
-            }.compact
+          next memo if (options[:state] && (options[:state] != ec.state)) ||
+                       !(entity_re.nil? || entity_re.match(entity)) ||
+                       !(check_re.nil?  || check_re.match(check))
+
+          ec.maintenances(nil, nil, type.to_sym => true).each do |window|
+            next unless (reason_re.nil? || reason_re.match(window[:summary])) &&
+              check_maintenance_timestamp(options[:started], window[:start_time]) &&
+              check_maintenance_timestamp(options[:finishing], window[:end_time]) &&
+              check_maintenance_interval(options[:duration], window[:duration])
+
+            memo << { :entity => entity,
+                      :check => check,
+                      :state => ec.state
+                    }.merge(window)
           end
-        }.compact
+
+          memo
+        end
       end
 
       def self.delete_maintenance(options = {})
@@ -666,6 +666,8 @@ module Flapjack
 
       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
@@ -678,8 +680,11 @@ module Flapjack
 
       # disables a check (removes currency)
       def disable!
+        timestamp = Time.now.to_i
         @logger.debug("disabling check [#{@key}]") if @logger
         entity_name = entity.name
+        @redis.zadd("all_checks", timestamp, @key)
+        @redis.zadd("all_checks:#{entity_name}", timestamp, check)
         @redis.zrem("current_checks:#{entity_name}", check)
         if @redis.zcount("current_checks:#{entity_name}", '-inf', '+inf') == 0
           @redis.zrem("current_checks:#{entity_name}", check)
@@ -690,8 +695,10 @@ module Flapjack
       def enable!
         timestamp = Time.now.to_i
         entity_name = entity.name
-        redis.zadd("current_checks:#{entity_name}", timestamp, check)
-        redis.zadd('current_entities', timestamp, entity_name)
+        @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 enabled?
@@ -977,6 +984,7 @@ module Flapjack
           "name"        => @check,
           "entity_name" => @entity.name,
           "enabled"     => opts[:enabled].is_a?(TrueClass),
+          "tags"        => self.tags.to_a,
           "links"       => {
             :entities     => opts[:entity_ids] || [],
           }
@@ -991,6 +999,11 @@ module Flapjack
         raise "Invalid entity" unless @entity = entity
         raise "Invalid check" unless @check = check
         @key = "#{entity.name}:#{check}"
+        if @redis.zscore("all_checks", @key).nil?
+          timestamp = options[:timestamp] || Time.now.to_i
+          @redis.zadd("all_checks", timestamp, @key)
+          @redis.zadd("all_checks:#{entity.name}", timestamp, check)
+        end
         @logger = options[:logger]
       end
 

data/lib/flapjack/data/event.rb

@@ -2,6 +2,8 @@
 
 require 'flapjack'
 
+require 'flapjack/data/migration'
+
 module Flapjack
   module Data
     class Event
@@ -77,24 +79,27 @@ module Flapjack
                      :events_archive_maxage => (3 * 60 * 60) }
         options  = defaults.merge(opts)
 
-        archive_dest = nil
+        archive_dest  = nil
         base_time_str = Time.now.utc.strftime("%Y%m%d%H")
 
         if options[:archive_events]
           archive_dest = "events_archive:#{base_time_str}"
+          unless @previous_base_time_str == base_time_str
+            Flapjack::Data::Migration.purge_expired_archive_index(:redis => redis)
+          end
+          @previous_base_time_str = base_time_str
           if options[:block]
             raw = redis.brpoplpush(queue, archive_dest, 0)
           else
             raw = redis.rpoplpush(queue, archive_dest)
             return unless raw
           end
+          redis.sadd("known_events_archive_keys", archive_dest)
+        elsif options[:block]
+          raw = redis.brpop(queue, 0)[1]
         else
-          if options[:block]
-            raw = redis.brpop(queue, 0)[1]
-          else
-            raw = redis.rpop(queue)
-            return unless raw
-          end
+          raw = redis.rpop(queue)
+          return unless raw
         end
         parsed = parse_and_validate(raw, :logger => options[:logger])
         if parsed.nil?

data/lib/flapjack/data/migration.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+require 'flapjack/data/semaphore'
+
+module Flapjack
+  module Data
+    class Migration
+
+      ENTITY_DATA_MIGRATION = 'entity_data_migration'
+
+      # copied from jsonapi/contact_methods.rb, could extract both into separate file
+      def self.obtain_semaphore(resource, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+
+        semaphore = nil
+        strikes = 0
+        begin
+          semaphore = Flapjack::Data::Semaphore.new(resource, :redis => redis, :expiry => 60)
+        rescue Flapjack::Data::Semaphore::ResourceLocked
+          strikes += 1
+          if strikes < 5
+            sleep 2
+            retry
+          end
+          sempahore = nil
+        end
+        semaphore
+      end
+
+      def self.migrate_entity_check_data_if_required(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+
+        logger = options[:logger]
+
+        semaphore = obtain_semaphore(ENTITY_DATA_MIGRATION, :redis => redis)
+        if semaphore.nil?
+          unless logger.nil?
+            logger.fatal "Could not obtain lock for data migration. Ensure that " +
+              "no other flapjack processes are running that might be executing " +
+              "migrations, check logs for any exceptions, manually delete the " +
+              "'#{ENTITY_DATA_MIGRATION}' key from your Flapjack Redis " +
+              "database and try running Flapjack again."
+          end
+          exit
+        end
+
+        if redis.exists('all_checks')
+          semaphore.release
+          return
+        end
+
+        logger.warn "Upgrading Flapjack's entity/check Redis indexes..." unless logger.nil?
+
+        check_names = redis.keys('check:*').map {|c| c.sub(/^check:/, '') } |
+          Flapjack::Data::EntityCheck.find_current_names(:redis => redis)
+
+        unless check_names.empty?
+          timestamp = Time.now.to_i
+
+          check_names.each do |ecn|
+            redis.zadd("all_checks", timestamp, ecn)
+            entity_name, check = ecn.split(':', 2)
+            redis.zadd("all_checks:#{entity_name}", timestamp, check)
+            # not deleting the check hashes, they store useful data
+          end
+        end
+
+        logger.warn "Checks indexed." unless logger.nil?
+
+        entity_name_keys = redis.keys("entity_id:*")
+        unless entity_name_keys.empty?
+          ids = redis.mget(*entity_name_keys)
+
+          entity_name_keys.each do |enk|
+            enk =~ /^entity_id:(.+)$/; entity_name = $1; entity_id = ids.shift
+
+            redis.hset('all_entity_names_by_id', entity_id, entity_name)
+            redis.hset('all_entity_ids_by_name', entity_name, entity_id)
+
+            redis.del(enk)
+            redis.del("entity:#{entity_id}")
+          end
+        end
+
+        logger.warn "Entities indexed." unless logger.nil?
+
+        semaphore.release
+
+        logger.warn "Indexing complete." unless logger.nil?
+      end
+
+      def self.refresh_archive_index(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        archive_keys = redis.keys('events_archive:*')
+        if archive_keys.empty?
+          redis.del('known_events_archive_keys')
+          return
+        end
+
+        grouped_keys = archive_keys.group_by do |ak|
+          (redis.llen(ak) > 0) ? 'add' : 'remove'
+        end
+
+        {'remove' => :srem, 'add' => :sadd}.each_pair do |k, cmd|
+          next unless grouped_keys.has_key?(k) && !grouped_keys[k].empty?
+          redis.send(cmd, 'known_events_archive_keys', grouped_keys[k])
+        end
+      end
+
+      def self.purge_expired_archive_index(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        return unless redis.exists('known_events_archive_keys')
+
+        redis.smembers('known_events_archive_keys').each do |ak|
+          redis.srem('known_events_archive_keys', ak) unless redis.exists(ak)
+        end
+      end
+
+    end
+  end
+end

data/lib/flapjack/gateways/jabber.rb

@@ -46,9 +46,10 @@ module Flapjack
         @redis_config = opts[:redis_config] || {}
         @boot_time = opts[:boot_time]
 
-        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
-
         @logger = opts[:logger]
+
+        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
+
         @logger.debug("Jabber Initializing")
 
         @buffer = []

data/lib/flapjack/gateways/jsonapi.rb

@@ -183,7 +183,7 @@ module Flapjack
 
       class << self
         def start
-          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
 
           @logger.info "starting jsonapi - class"
 

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

@@ -28,6 +28,7 @@ module Flapjack
            'in_unscheduled_maintenance'        => @entity_check.in_unscheduled_maintenance?,
            'in_scheduled_maintenance'          => @entity_check.in_scheduled_maintenance?,
            'last_update'                       => @entity_check.last_update,
+           'last_change'                       => @entity_check.last_change,
            'last_problem_notification'         => @entity_check.last_notification_for_state(:problem)[:timestamp],
            'last_recovery_notification'        => @entity_check.last_notification_for_state(:recovery)[:timestamp],
            'last_acknowledgement_notification' => @entity_check.last_notification_for_state(:acknowledgement)[:timestamp]}

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

@@ -25,11 +25,11 @@ module Flapjack
               semaphore = Flapjack::Data::Semaphore.new(resource, :redis => redis, :expiry => 30)
             rescue Flapjack::Data::Semaphore::ResourceLocked
               strikes += 1
-              raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless strikes < 3
+              raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) if strikes >= 3
               sleep 1
               retry
             end
-            raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless semaphore
+            raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) if semaphore.nil?
             semaphore
           end
 
@@ -144,9 +144,6 @@ module Flapjack
                       unless notification_rule.nil?
                         contact.grab_notification_rule(notification_rule)
                       end
-                    when 'tags'
-                      value.respond_to?(:each) ? contact.add_tags(*value) :
-                                                 contact.add_tags(value)
                     # when 'media' # not supported yet due to id brokenness
                     end
                   when 'remove'
@@ -159,9 +156,6 @@ module Flapjack
                       unless notification_rule.nil?
                         contact.delete_notification_rule(notification_rule)
                       end
-                    when 'tags'
-                      value.respond_to?(:each) ? contact.delete_tags(*value) :
-                                                 contact.delete_tags(value)
                     # when 'media' # not supported yet due to id brokenness
                     end
                   end

data/lib/flapjack/gateways/pagerduty.rb

@@ -23,7 +23,7 @@ module Flapjack
         @config = opts[:config]
         @logger = opts[:logger]
         @redis_config = opts[:redis_config] || {}
-        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
 
         @logger.debug("New Pagerduty pikelet with the following options: #{@config.inspect}")
 

data/lib/flapjack/gateways/web.rb

@@ -40,7 +40,7 @@ module Flapjack
 
       class << self
         def start
-          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
 
           @logger.info "starting web - class"
 

data/lib/flapjack/notifier.rb

@@ -26,7 +26,7 @@ module Flapjack
       @config = opts[:config]
       @redis_config = opts[:redis_config] || {}
       @logger = opts[:logger]
-      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
 
       @notifications_queue = @config['queue'] || 'notifications'
 

data/lib/flapjack/pikelet.rb

@@ -97,7 +97,7 @@ module Flapjack
 
       def configure_resque
         unless ::Resque.instance_variable_defined?('@flapjack_pool') && !::Resque.instance_variable_get('@flapjack_pool').nil?
-          resque_pool = Flapjack::RedisPool.new(:config => @redis_config)
+          resque_pool = Flapjack::RedisPool.new(:config => @redis_config, :logger => @logger)
           ::Resque.instance_variable_set('@flapjack_pool', resque_pool)
           ::Resque.redis = resque_pool
         end
@@ -175,7 +175,7 @@ module Flapjack
 
         # guard against another Resque pikelet having created the pool already
         unless defined?(@@redis_connection) && !@@redis_connection.nil?
-          @@redis_connection = Flapjack::RedisPool.new(:config => @redis_config)
+          @@redis_connection = Flapjack::RedisPool.new(:config => @redis_config, :logger => @logger)
         end
 
         pikelet_klass.instance_variable_set('@config', @config)

data/lib/flapjack/processor.rb

@@ -26,7 +26,7 @@ module Flapjack
       @redis_config = opts[:redis_config] || {}
       @logger = opts[:logger]
 
-      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
 
       @queue = @config['queue'] || 'events'