flapjack 1.1.0 → 1.2.0rc1

data/lib/flapjack/data/entity_check.rb

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
 
-require 'oj'
-
 require 'flapjack/patches'
 
 require 'flapjack/data/contact'
 require 'flapjack/data/event'
 require 'flapjack/data/entity'
+require 'flapjack/data/tagged'
+
 #FIXME: Require chronic_duration in the correct place
 require 'chronic_duration'
 
@@ -27,8 +27,37 @@ module Flapjack
       NOTIFICATION_STATES = [:problem, :warning, :critical, :unknown,
                              :recovery, :acknowledgement]
 
+      include Tagged
+
       attr_accessor :entity, :check
 
+      def self.add(check_data, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+
+        entity_id  = check_data['entity_id']
+        raise "Entity id not provided" if entity_id.nil? || entity_id.empty?
+
+        check_name = check_data['name']
+        raise "Name not provided" if check_name.nil? || check_name.empty?
+
+        ent = Flapjack::Data::Entity.find_by_id(entity_id, :redis => redis)
+
+        raise "Entity not found for id '#{entity_id}'" if ent.nil?
+
+        logger = options[:logger]
+        timestamp = Time.now.to_i
+
+        redis.zadd("current_checks:#{ent.name}", timestamp, check_name)
+        redis.zadd('current_entities', timestamp, ent.name)
+
+        c = self.new(ent, check_name, :logger  => logger,
+                     :redis => redis)
+        if check_data['tags'] && check_data['tags'].respond_to?(:each)
+          c.add_tags(*check_data['tags'])
+        end
+        c
+      end
+
       def self.for_event_id(event_id, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         entity_name, check_name = event_id.split(':', 2)
@@ -36,6 +65,7 @@ module Flapjack
         logger = options[:logger]
         entity = Flapjack::Data::Entity.find_by_name(entity_name,
           :create => create_entity, :logger => logger, :redis => redis)
+        return if entity.nil?
         self.new(entity, check_name, :logger => logger, :redis => redis)
       end
 
@@ -65,23 +95,30 @@ 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}
+        checks = redis.keys('check:*').map {|c| c.match(/^check:(.+)$/) ; $1} |
+                   find_current_names(:redis => redis)
         checks.map {|ec|
-          self.for_entity_id(ec, options)
+          self.for_event_id(ec, options)
         }
       end
 
-      def self.find_current_for_entity_name(entity_name, options = {})
+      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}
+      end
+
+      def self.find_current_names_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_current(options = {})
+      def self.find_current_names(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        self.conflate_to_keys(self.find_current_by_entity(:redis => redis))
+        self.conflate_to_keys(self.find_current_names_by_entity(:redis => redis))
       end
 
-      def self.find_current_by_entity(options = {})
+      def self.find_current_names_by_entity(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         d = {}
         redis.zrange("current_entities", 0, -1).each {|entity|
@@ -97,12 +134,12 @@ module Flapjack
         }
       end
 
-      def self.find_current_failing(options = {})
+      def self.find_current_names_failing(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        self.conflate_to_keys(self.find_current_failing_by_entity(:redis => redis))
+        self.conflate_to_keys(self.find_current_names_failing_by_entity(:redis => redis))
       end
 
-      def self.find_current_failing_by_entity(options = {})
+      def self.find_current_names_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)
@@ -642,13 +679,21 @@ module Flapjack
       # 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)
+        entity_name = entity.name
+        @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 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)
+      end
+
       def enabled?
         !!@redis.zscore("current_checks:#{entity.name}", check)
       end
@@ -855,13 +900,24 @@ module Flapjack
         }.compact
       end
 
-      def tags
-        entity, check = @key.split(":", 2)
-        ta = Flapjack::Data::TagSet.new([])
-        ta += entity.split('.', 2).map {|x| x.downcase}
-        ta += check.split(' ').map {|x| x.downcase}
+      # override default, which would be 'entity_check_tag'
+      def tag_prefix
+        'check_tag'
+      end
+
+      def tags_with_entity_and_check_name
+        tags_without_entity_and_check_name
+
+        # ensure that returned tags include split entity and check words
+        @tags += @entity.name.split('.', 2).map {|x| x.downcase} +
+          @check.split(' ').map {|x| x.downcase}
+
+        @tags
       end
 
+      alias_method :tags_without_entity_and_check_name, :tags
+      alias_method :tags, :tags_with_entity_and_check_name
+
       def ack_hash
         @ack_hash ||= @redis.hget('check_hashes_by_id', @key)
         if @ack_hash.nil?
@@ -905,14 +961,27 @@ module Flapjack
         purge_stamps.length
       end
 
+      def self.enabled_for(check_ids, opts = {})
+        raise "Redis connection not set" unless redis = opts[:redis]
+
+        check_ids.inject([]) do |memo, check_id|
+          entity_name, check_name = check_id.split(':', 2)
+          memo << check_id unless redis.zscore("current_checks:#{entity_name}", check_name).nil?
+          memo
+        end
+      end
+
       def to_jsonapi(opts = {})
-        {
+        json_data = {
+          "id"          => @key,
           "name"        => @check,
           "entity_name" => @entity.name,
+          "enabled"     => opts[:enabled].is_a?(TrueClass),
           "links"       => {
             :entities     => opts[:entity_ids] || [],
           }
-        }.to_json
+        }
+        Flapjack.dump_json(json_data)
       end
 
     private

data/lib/flapjack/data/event.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'oj'
-require 'flapjack/data/tag_set'
+require 'flapjack'
 
 module Flapjack
   module Data
@@ -120,7 +119,7 @@ module Flapjack
 
       def self.parse_and_validate(raw, opts = {})
         errors = []
-        if parsed = ::Oj.load(raw)
+        if parsed = ::Flapjack.load_json(raw)
           if parsed.is_a?(Hash)
             errors = validation_errors_for_hash(parsed, opts)
           else
@@ -177,7 +176,7 @@ module Flapjack
         raise "Redis connection not set" unless redis = opts[:redis]
 
         evt['time'] = Time.now.to_i if evt['time'].nil?
-        redis.lpush('events', ::Oj.dump(evt))
+        redis.lpush('events', ::Flapjack.dump_json(evt))
       end
 
       # Provide a count of the number of events on the queue to be processed.
@@ -220,7 +219,7 @@ module Flapjack
         # perfdata is optional. set it to nil if it only contains whitespace
         @perfdata = (@perfdata.is_a?(String) && ! @perfdata.strip.empty?) ? @perfdata.strip : nil
         if attrs['tags']
-          @tags = Flapjack::Data::TagSet.new
+          @tags = Set.new
           attrs['tags'].each {|tag| @tags.add(tag)}
         end
       end

data/lib/flapjack/data/notification.rb

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'oj'
-
 require 'flapjack/data/contact'
 require 'flapjack/data/event'
 require 'flapjack/data/message'
@@ -66,7 +64,7 @@ module Flapjack
                  'severity'       => opts[:severity],
                  'tags'           => tag_data }
 
-        redis.rpush(queue, Oj.dump(notif))
+        redis.rpush(queue, Flapjack.dump_json(notif))
       end
 
       def self.next(queue, opts = {})
@@ -82,7 +80,7 @@ module Flapjack
           return unless raw
         end
         begin
-          parsed = ::Oj.load( raw )
+          parsed = ::Flapjack.load_json( raw )
         rescue Oj::Error => e
           if options[:logger]
             options[:logger].warn("Error deserialising notification json: #{e}, raw json: #{raw.inspect}")
@@ -133,7 +131,7 @@ module Flapjack
           media = contact.media
 
           logger.debug "Notification#messages: creating messages for contact: #{contact_id} " +
-            "event_id: \"#{@event_id}\" state: #{@state} event_tags: #{@tags.to_json} media: #{media.inspect}"
+            "event_id: \"#{@event_id}\" state: #{@state} event_tags: #{Flapjack.dump_json(@tags)} media: #{media.inspect}"
           rlen = rules.length
           logger.debug "found #{rlen} rule#{(rlen == 1) ? '' : 's'} for contact #{contact_id}"
 
@@ -144,7 +142,7 @@ module Flapjack
             # for time, entity and tags
             matchers = rules.select do |rule|
               logger.debug("considering rule with entities: #{rule.entities}, entities regex: #{rule.regex_entities},
-                           tags: #{rule.tags.to_json} and regex tags: #{rule.regex_tags.to_json}")
+                           tags: #{Flapjack.dump_json(rule.tags)} and regex tags: #{Flapjack.dump_json(rule.regex_tags)}")
               rule_has_tags           = rule.tags           ? (rule.tags.length > 0)           : false
               rule_has_regex_tags     = rule.regex_tags     ? (rule.regex_tags.length > 0)     : false
               rule_has_entities       = rule.entities       ? (rule.entities.length > 0)       : false
@@ -162,7 +160,7 @@ module Flapjack
 
             logger.debug "#{matchers.length} matchers remain for this contact after time, entity and tags are matched:"
             matchers.each do |matcher|
-              logger.debug "  - #{matcher.to_json}"
+              logger.debug "  - #{matcher.to_jsonapi}"
             end
 
             # delete any general matchers if there are more specific matchers left
@@ -175,7 +173,7 @@ module Flapjack
               if num_matchers != matchers.length
                 logger.debug("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}")
                 matchers.each do |matcher|
-                  logger.debug "  - #{matcher.to_json}"
+                  logger.debug "  - #{matcher.to_jsonapi}"
                 end
               end
             end
@@ -185,7 +183,7 @@ module Flapjack
             if blackhole_matchers.length > 0
               logger.debug "dropping this media as #{blackhole_matchers.length} blackhole matchers are present:"
               blackhole_matchers.each {|bm|
-                logger.debug "  - #{bm.to_json}"
+                logger.debug "  - #{bm.to_jsonapi}"
               }
               next
             else
@@ -264,7 +262,7 @@ module Flapjack
         @state_duration = opts['state_duration']
         @type           = opts['type']
         @severity       = opts['severity']
-        @tags           = opts['tags'].is_a?(Array) ? Flapjack::Data::TagSet.new(opts['tags']) : nil
+        @tags           = opts['tags'].is_a?(Array) ? Set.new(opts['tags']) : nil
       end
 
       # # time restrictions match?

data/lib/flapjack/data/notification_rule.rb

@@ -1,10 +1,8 @@
 #!/usr/bin/env ruby
 
-require 'oj'
 require 'active_support/time'
 require 'ice_cube'
 require 'flapjack/utility'
-require 'flapjack/data/tag_set'
 
 module Flapjack
   module Data
@@ -108,20 +106,19 @@ module Flapjack
         nil
       end
 
-      def to_json(*args)
-        self.class.hashify(:id, :contact_id, :tags, :regex_tags, :entities, :regex_entities,
-            :time_restrictions, :unknown_media, :warning_media, :critical_media,
-            :unknown_blackhole, :warning_blackhole, :critical_blackhole) {|k|
-          [k, self.send(k)]
-        }.to_json
-      end
-
       def to_jsonapi(opts = {})
-        self.class.hashify(:id, :tags, :regex_tags, :entities, :regex_entities,
+        json_data = self.class.hashify(:id, :tags, :regex_tags, :entities, :regex_entities,
             :time_restrictions, :unknown_media, :warning_media, :critical_media,
             :unknown_blackhole, :warning_blackhole, :critical_blackhole) {|k|
-          [k, self.send(k)]
-        }.merge(:links => {:contacts => [self.contact_id]}).to_json
+          case k
+          when :tags, :regex_tags
+            [k.to_s, self.send(k).to_a.sort]
+          else
+            [k.to_s, self.send(k)]
+          end
+        }.merge('links' => {'contacts' => [self.contact_id]})
+
+        Flapjack.dump_json(json_data)
       end
 
       # entity names match?
@@ -203,10 +200,10 @@ module Flapjack
         rule_data[:warning_blackhole]  = rule_data[:warning_blackhole] || false
         rule_data[:critical_blackhole] = rule_data[:critical_blackhole] || false
         if rule_data[:tags].is_a?(Array)
-          rule_data[:tags] = Flapjack::Data::TagSet.new(rule_data[:tags])
+          rule_data[:tags] = Set.new(rule_data[:tags])
         end
         if rule_data[:regex_tags].is_a?(Array)
-          rule_data[:regex_tags] = Flapjack::Data::TagSet.new(rule_data[:regex_tags])
+          rule_data[:regex_tags] = Set.new(rule_data[:regex_tags])
         end
         rule_data
       end
@@ -227,14 +224,14 @@ module Flapjack
         json_rule_data = {
           :id                 => rule_data[:id].to_s,
           :contact_id         => rule_data[:contact_id].to_s,
-          :entities           => Oj.dump(rule_data[:entities]),
-          :regex_entities     => Oj.dump(rule_data[:regex_entities]),
-          :tags               => Oj.dump(tag_data),
-          :regex_tags         => Oj.dump(regex_tag_data),
-          :time_restrictions  => Oj.dump(rule_data[:time_restrictions], :mode => :compat),
-          :unknown_media      => Oj.dump(rule_data[:unknown_media]),
-          :warning_media      => Oj.dump(rule_data[:warning_media]),
-          :critical_media     => Oj.dump(rule_data[:critical_media]),
+          :entities           => Flapjack.dump_json(rule_data[:entities]),
+          :regex_entities     => Flapjack.dump_json(rule_data[:regex_entities]),
+          :tags               => Flapjack.dump_json(tag_data),
+          :regex_tags         => Flapjack.dump_json(regex_tag_data),
+          :time_restrictions  => Flapjack.dump_json(rule_data[:time_restrictions]),
+          :unknown_media      => Flapjack.dump_json(rule_data[:unknown_media]),
+          :warning_media      => Flapjack.dump_json(rule_data[:warning_media]),
+          :critical_media     => Flapjack.dump_json(rule_data[:critical_media]),
           :unknown_blackhole  => rule_data[:unknown_blackhole],
           :warning_blackhole  => rule_data[:warning_blackhole],
           :critical_blackhole => rule_data[:critical_blackhole],
@@ -323,13 +320,13 @@ module Flapjack
 
         proc {|d| !d.has_key?(:tags) ||
                ( d[:tags].nil? ||
-                 d[:tags].is_a?(Flapjack::Data::TagSet) &&
+                 d[:tags].is_a?(Set) &&
                  d[:tags].all? {|et| et.is_a?(String)} ) } =>
         "tags must be a tag_set of strings",
 
         proc {|d| !d.has_key?(:regex_tags) ||
                ( d[:regex_tags].nil? ||
-                 d[:regex_tags].is_a?(Flapjack::Data::TagSet) &&
+                 d[:regex_tags].is_a?(Set) &&
                  d[:regex_tags].all? {|et| et.is_a?(String)} ) } =>
         "regex_tags must be a tag_set of strings",
 
@@ -400,16 +397,16 @@ module Flapjack
         rule_data = @redis.hgetall("notification_rule:#{@id}")
 
         @contact_id         = rule_data['contact_id']
-        tags                = Oj.load(rule_data['tags'] || '')
-        @tags               = tags ? Flapjack::Data::TagSet.new(tags) : nil
-        regex_tags          = Oj.load(rule_data['regex_tags'] || '')
-        @regex_tags         = regex_tags ? Flapjack::Data::TagSet.new(regex_tags) : nil
-        @entities           = Oj.load(rule_data['entities'] || '')
-        @regex_entities     = Oj.load(rule_data['regex_entities'] || '')
-        @time_restrictions  = Oj.load(rule_data['time_restrictions'] || '')
-        @unknown_media      = Oj.load(rule_data['unknown_media'] || '')
-        @warning_media      = Oj.load(rule_data['warning_media'] || '')
-        @critical_media     = Oj.load(rule_data['critical_media'] || '')
+        tags                = Flapjack.load_json(rule_data['tags'] || '')
+        @tags               = tags ? Set.new(tags) : nil
+        regex_tags          = Flapjack.load_json(rule_data['regex_tags'] || '')
+        @regex_tags         = regex_tags ? Set.new(regex_tags) : nil
+        @entities           = Flapjack.load_json(rule_data['entities'] || '')
+        @regex_entities     = Flapjack.load_json(rule_data['regex_entities'] || '')
+        @time_restrictions  = Flapjack.load_json(rule_data['time_restrictions'] || '')
+        @unknown_media      = Flapjack.load_json(rule_data['unknown_media'] || '')
+        @warning_media      = Flapjack.load_json(rule_data['warning_media'] || '')
+        @critical_media     = Flapjack.load_json(rule_data['critical_media'] || '')
         @unknown_blackhole  = ((rule_data['unknown_blackhole'] || 'false').downcase == 'true')
         @warning_blackhole  = ((rule_data['warning_blackhole'] || 'false').downcase == 'true')
         @critical_blackhole = ((rule_data['critical_blackhole'] || 'false').downcase == 'true')

data/lib/flapjack/data/tagged.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+# mixed in to some of the Flapjack data classes
+
+module Flapjack
+
+  module Tagged
+
+    def tag_prefix
+      self.class.name.split('::').last.downcase + '_tag'
+    end
+
+    def known_key
+      "known_tags:#{tag_prefix}"
+    end
+
+    # return the set of tags for this object
+    def tags
+      return @tags unless @tags.nil?
+      @tags ||= Set.new( @redis.smembers(known_key).inject([]) {|memo, t|
+        tag_key = "#{tag_prefix}:#{t}"
+        memo << t if @redis.sismember(tag_key, @id.to_s)
+        memo
+      })
+    end
+
+    # adds tags to this object
+    def add_tags(*enum)
+      enum.each do |t|
+        @redis.sadd(known_key, t)
+        @redis.sadd("#{tag_prefix}:#{t}", @id)
+        tags.add(t)
+      end
+    end
+
+    # removes tags from this object
+    def delete_tags(*enum)
+      enum.each do |t|
+        tag_key = "#{tag_prefix}:#{t}"
+        @redis.srem(tag_key, @id)
+        tags.delete(t)
+        @redis.srem(known_key, t) if (@redis.scard(tag_key) == 0)
+      end
+    end
+
+  end
+
+end

data/lib/flapjack/gateways/jabber.rb

@@ -6,7 +6,6 @@ require 'socket'
 
 require 'blather/client/client'
 require 'chronic_duration'
-require 'oj'
 
 require 'flapjack/data/entity_check'
 require 'flapjack/redis_pool'
@@ -69,7 +68,7 @@ module Flapjack
         redis_uri = @redis_config[:path] ||
           "redis://#{@redis_config[:host] || '127.0.0.1'}:#{@redis_config[:port] || '6379'}/#{@redis_config[:db] || '0'}"
         shutdown_redis = EM::Hiredis.connect(redis_uri)
-        shutdown_redis.rpush(@config['queue'], Oj.dump('notification_type' => 'shutdown'))
+        shutdown_redis.rpush(@config['queue'], Flapjack.dump_json('notification_type' => 'shutdown'))
       end
 
       def setup
@@ -398,7 +397,7 @@ module Flapjack
             when number_found == 0
               msg = "found no entities matching /#{entity_pattern}/"
             when number_found >= 1
-              failing_list = Flapjack::Data::EntityCheck.find_current_failing_by_entity(:redis => @redis)
+              failing_list = Flapjack::Data::EntityCheck.find_current_names_failing_by_entity(:redis => @redis)
               entities = failing_list.select {|k,v| v.count >= 1 && entity_list.include?(k) }
               if entities.length >= 1
                 entities.each_pair do |entity,check_list|
@@ -474,7 +473,7 @@ module Flapjack
               msg = "found no entities matching /#{entity_pattern}/"
             when number_found >= 1
 
-              failing_list = Flapjack::Data::EntityCheck.find_current_failing_by_entity(:redis => @redis)
+              failing_list = Flapjack::Data::EntityCheck.find_current_names_failing_by_entity(:redis => @redis)
 
               my_failing_checks = Hash[failing_list.map do |k,v|
                 if entity_list.include?(k)
@@ -695,7 +694,7 @@ module Flapjack
           events[queue] = @redis.blpop(queue, 0)
           event_json = events[queue][1]
           begin
-            event = Oj.load(event_json)
+            event = Flapjack.load_json(event_json)
 
             @logger.debug('jabber notification event received: ' + event.inspect)
 

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

@@ -43,34 +43,72 @@ module Flapjack
                 Flapjack::Data::EntityCheck.for_event_id(req_check, :logger => logger, :redis => redis)
               end
             else
-              Flapjack::Data::EntityCheck.find_current(:redis => redis)
+              Flapjack::Data::EntityCheck.all(:logger => logger, :redis => redis)
             end
             checks.compact!
 
             if requested_checks && checks.empty?
-              raise Flapjack::Gateways::JSONAPI::ChecksNotFound.new(requested_checks)
+              raise Flapjack::Gateways::JSONAPI::EntityChecksNotFound.new(requested_checks)
             end
 
+            check_ids = checks.collect {|c| "#{c.entity.name}:#{c.check}" }
+
+            enabled_ids = Flapjack::Data::EntityCheck.enabled_for(check_ids, :redis => redis)
+
             linked_entity_ids = checks.empty? ? [] : checks.inject({}) do |memo, check|
-              memo[check.key] = check.entity.id
+              entity = check.entity
+              memo["#{entity.name}:#{check.check}"] = [entity.id]
               memo
             end
 
             checks_json = checks.collect {|check|
-              check.to_jsonapi(:entity_ids => linked_entity_ids[check.key])
+              check_name = "#{check.entity.name}:#{check.check}"
+              check.to_jsonapi(:enabled    => enabled_ids.include?(check_name),
+                               :entity_ids => linked_entity_ids[check_name])
             }.join(",")
 
             '{"checks":[' + checks_json + ']}'
           end
 
+          app.post '/checks' do
+            checks = wrapped_params('checks')
+
+            check_names = checks.collect{|check_data|
+              check = Flapjack::Data::EntityCheck.add(check_data, :redis => redis)
+              "#{check.entity.name}:#{check.check}"
+            }
+
+            response.headers['Location'] = "#{request.base_url}/checks/#{check_names.join(',')}"
+            status 201
+            Flapjack.dump_json(check_names)
+          end
+
           app.patch %r{^/checks/(.+)$} do
             checks_for_check_names(params[:captures][0].split(',')).each do |check|
               apply_json_patch('checks') do |op, property, linked, value|
                 case op
                 when 'replace'
-                  if ['enabled'].include?(property)
-                    # explicitly checking for false being passed in
-                    check.disable! if value.is_a?(FalseClass)
+                  case property
+                  when 'enabled'
+                    # explicitly checking for true/false being passed in
+                    case value
+                    when TrueClass
+                      check.enable!
+                    when FalseClass
+                      check.disable!
+                    end
+                  end
+                when 'add'
+                  case linked
+                  when 'tags'
+                    value.respond_to?(:each) ? check.add_tags(*value) :
+                                               check.add_tags(value)
+                  end
+                when 'remove'
+                  case linked
+                  when 'tags'
+                    value.respond_to?(:each) ? check.delete_tags(*value) :
+                                               check.delete_tags(value)
                   end
                 end
               end

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

@@ -36,7 +36,7 @@ module Flapjack
         def outage(start_time, end_time, options = {})
           # hist_states is an array of hashes, with [state, timestamp, summary] keys
           hist_states = @entity_check.historical_states(start_time, end_time)
-          return hist_states if hist_states.empty?
+          return {:outages => []} if hist_states.empty?
 
           initial = @entity_check.historical_state_before(hist_states.first[:timestamp])
           hist_states.unshift(initial) if initial

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

@@ -45,7 +45,7 @@ module Flapjack
             missing_ids = contacts_by_id.select {|k, v| v.nil? }.keys
             unless missing_ids.empty?
               semaphore.release
-              halt(404, "Contacts with ids #{missing_ids.join(', ')} were not found")
+              raise Flapjack::Gateways::JSONAPI::ContactsNotFound.new(missing_ids)
             end
 
             block.call(contacts_by_id.select {|k, v| !v.nil? }.values)
@@ -93,7 +93,7 @@ module Flapjack
 
             response.headers['Location'] = "#{base_url}/contacts/#{contact_ids.join(',')}"
             status 201
-            contact_ids.to_json
+            Flapjack.dump_json(contact_ids)
           end
 
           # Returns all (/contacts) or some (/contacts/1,2,3) or one (/contacts/2) contact(s)
@@ -144,6 +144,9 @@ 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'
@@ -156,6 +159,9 @@ 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