sensu 0.9.9.beta → 0.9.9.beta.1

data/CHANGELOG.md

@@ -8,14 +8,21 @@ via the API (/info).
 Aggregate results available via the API when using a parameter
 (?results=true).
 
+Event filters; filtering events for handlers, using event attribute
+matching.
+
 ### Other
 
 Server is now using basic AMQP QoS (prefetch), just enough back pressure.
 
+Improved check execution scheduling.
+
 Fixed server execute command method error handling.
 
 Events with a resolve action bypass handler severity filtering.
 
+Check flap detection configuration validation.
+
 ## 0.9.8 - 2012-11-15
 
 ### Features

data/lib/sensu/api.rb

@@ -443,17 +443,25 @@ module Sensu
       response = Array.new
       $redis.smembers('aggregates').callback do |checks|
         unless checks.empty?
-          checks.each_with_index do |check_name, index|
-            $redis.smembers('aggregates:' + check_name).callback do |aggregates|
-              collection = {
-                :check => check_name,
-                :issued => aggregates.sort.reverse.take(10)
-              }
-              response.push(collection)
-              if index == checks.size - 1
-                body response.to_json
+          limit = 10
+          if params[:limit]
+            limit = params[:limit] =~ /^[0-9]+$/ ? params[:limit].to_i : nil
+          end
+          unless limit.nil?
+            checks.each_with_index do |check_name, index|
+              $redis.smembers('aggregates:' + check_name).callback do |aggregates|
+                collection = {
+                  :check => check_name,
+                  :issued => aggregates.sort.reverse.take(limit)
+                }
+                response.push(collection)
+                if index == checks.size - 1
+                  body response.to_json
+                end
               end
             end
+          else
+            bad_request!
           end
         else
           body response.to_json
@@ -463,7 +471,38 @@ module Sensu
 
     aget %r{/aggregates/([\w\.-]+)$} do |check_name|
       $redis.smembers('aggregates:' + check_name).callback do |aggregates|
-        body aggregates.sort.reverse.take(10).to_json
+        unless aggregates.empty?
+          limit = 10
+          if params[:limit]
+            limit = params[:limit] =~ /^[0-9]+$/ ? params[:limit].to_i : nil
+          end
+          unless limit.nil?
+            body aggregates.sort.reverse.take(limit).to_json
+          else
+            bad_request!
+          end
+        else
+          not_found!
+        end
+      end
+    end
+
+    adelete %r{/aggregates/([\w\.-]+)$} do |check_name|
+      $redis.smembers('aggregates:' + check_name).callback do |aggregates|
+        unless aggregates.empty?
+          aggregates.each do |check_issued|
+            result_set = check_name + ':' + check_issued
+            $redis.del('aggregation:' + result_set)
+            $redis.del('aggregate:' + result_set)
+          end
+          $redis.del('aggregates:' + check_name).callback do
+            $redis.srem('aggregates', check_name).callback do
+              no_content!
+            end
+          end
+        else
+          not_found!
+        end
       end
     end
 

data/lib/sensu/constants.rb

@@ -1,6 +1,6 @@
 module Sensu
   unless defined?(Sensu::VERSION)
-    VERSION = '0.9.9.beta'
+    VERSION = '0.9.9.beta.1'
   end
 
   unless defined?(Sensu::DEFAULT_OPTIONS)

data/lib/sensu/server.rb

@@ -136,6 +136,21 @@ module Sensu
       subdue && subdue_at == (check[:subdue][:at] || 'handler').to_sym
     end
 
+    def event_filtered?(filter_name, event)
+      if @settings.filter_exists?(filter_name)
+        filter = @settings[:filters][filter_name]
+        matched = hash_values_equal?(filter[:attributes], event)
+        filter[:negate] ? matched : !matched
+      else
+        @logger.error('unknown filter', {
+          :filter => {
+            :name => filter_name
+          }
+        })
+        false
+      end
+    end
+
     def derive_handlers(handler_list, nested=false)
       handler_list.inject(Array.new) do |handlers, handler_name|
         if @settings.handler_exists?(handler_name)
@@ -167,23 +182,43 @@ module Sensu
       handlers = derive_handlers(handler_list)
       event_severity = Sensu::SEVERITIES[event[:check][:status]] || 'unknown'
       handlers.select do |handler|
-        if check_subdued?(event[:check], :handler)
-          @logger.info('check is subdued at handler', {
+        if event[:action] == :flapping && !handler[:handle_flapping]
+          @logger.info('handler does not handle flapping events', {
             :event => event,
             :handler => handler
           })
-          false
-        elsif event[:action] == :resolve
-          true
-        elsif handler.has_key?(:severities) && !handler[:severities].include?(event_severity)
-          @logger.debug('handler does not handle event severity', {
+          next
+        end
+        if check_subdued?(event[:check], :handler)
+          @logger.info('check is subdued at handler', {
             :event => event,
             :handler => handler
           })
-          false
-        else
-          true
+          next
         end
+        if handler.has_key?(:severities) && !handler[:severities].include?(event_severity)
+          unless event[:action] == :resolve
+            @logger.debug('handler does not handle event severity', {
+              :event => event,
+              :handler => handler
+            })
+            next
+          end
+        end
+        if handler.has_key?(:filters) || handler.has_key?(:filter)
+          filter_list = Array(handler[:filters] || handler[:filter])
+          filtered = filter_list.any? do |filter_name|
+            event_filtered?(filter_name, event)
+          end
+          if filtered
+            @logger.debug('event filtered for handler', {
+              :event => event,
+              :handler => handler
+            })
+            next
+          end
+        end
+        true
       end
     end
 
@@ -417,8 +452,8 @@ module Sensu
                     :flapping => is_flapping,
                     :occurrences => event[:occurrences]
                   }.to_json).callback do
-                    unless check[:handle] == false || is_flapping
-                      event[:action] = :create
+                    unless check[:handle] == false
+                      event[:action] = is_flapping ? :flapping : :create
                       handle_event(event)
                     end
                   end
@@ -545,7 +580,7 @@ module Sensu
           checks.each do |check_name|
             @redis.smembers('aggregates:' + check_name).callback do |aggregates|
               aggregates.sort!
-              until aggregates.size <= 10
+              until aggregates.size <= 20
                 check_issued = aggregates.shift
                 @redis.srem('aggregates:' + check_name, check_issued).callback do
                   result_set = check_name + ':' + check_issued.to_s
@@ -719,5 +754,19 @@ module Sensu
         end
       end
     end
+
+    def hash_values_equal?(hash_one, hash_two)
+      hash_one.keys.all? do |key|
+        if hash_one[key] == hash_two[key]
+          true
+        else
+          if hash_one[key].is_a?(Hash) && hash_two[key].is_a?(Hash)
+            hash_values_equal?(hash_one[key], hash_two[key])
+          else
+            false
+          end
+        end
+      end
+    end
   end
 end

data/lib/sensu/settings.rb

@@ -5,7 +5,7 @@ module Sensu
     def initialize
       @logger = Sensu::Logger.get
       @settings = Hash.new
-      [:checks, :handlers, :mutators].each do |key|
+      [:checks, :filters, :mutators, :handlers].each do |key|
         @settings[key] = Hash.new
       end
       @indifferent_access = false
@@ -89,7 +89,7 @@ module Sensu
       ENV['SENSU_CONFIG_FILES'] = @loaded_files.join(':')
     end
 
-    [:checks, :handlers, :mutators].each do |key|
+    [:checks, :filters, :mutators, :handlers].each do |key|
       define_method(key) do
         @settings[key].map do |name, details|
           details.merge(:name => name.to_s)
@@ -217,6 +217,27 @@ module Sensu
               :check => check
             })
           end
+          check[:handlers].each do |handler_name|
+            unless handler_name.is_a?(String)
+              invalid('check handlers items must be strings', {
+                :check => check
+              })
+            end
+          end
+        end
+        if check.has_key?(:low_flap_threshold)
+          unless check[:low_flap_threshold].is_a?(Integer)
+            invalid('flap thresholds must be integers', {
+              :check => check
+            })
+          end
+        end
+        if check.has_key?(:high_flap_threshold)
+          unless check[:high_flap_threshold].is_a?(Integer)
+            invalid('flap thresholds must be integers', {
+              :check => check
+            })
+          end
         end
         if check.has_key?(:subdue)
           unless check[:subdue].is_a?(Hash)
@@ -315,6 +336,33 @@ module Sensu
     end
 
     def validate_server
+      unless @settings[:filters].is_a?(Hash)
+        invalid('filters must be a hash')
+      end
+      filters.each do |filter|
+        unless filter[:attributes].is_a?(Hash)
+          invalid('filter attributes must be a hash', {
+            :filter => filter
+          })
+        end
+        if filter.has_key?(:negate)
+          unless !!filter[:negate] == filter[:negate]
+            invalid('filter negate must be boolean', {
+              :filter => filter
+            })
+          end
+        end
+      end
+      unless @settings[:mutators].is_a?(Hash)
+        invalid('mutators must be a hash')
+      end
+      mutators.each do |mutator|
+        unless mutator[:command].is_a?(String)
+          invalid('mutator is missing command', {
+            :mutator => mutator
+          })
+        end
+      end
       unless @settings[:handlers].is_a?(Hash)
         invalid('handlers must be a hash')
       end
@@ -327,20 +375,6 @@ module Sensu
             :handler => handler
           })
         end
-        if handler.has_key?(:severities)
-          unless handler[:severities].is_a?(Array) && !handler[:severities].empty?
-            invalid('handler severities must be an array and not empty', {
-              :handler => handler
-            })
-          end
-          handler[:severities].each do |severity|
-            unless Sensu::SEVERITIES.include?(severity)
-              invalid('handler severities are invalid', {
-                :handler => handler
-              })
-            end
-          end
-        end
         case handler[:type]
         when 'pipe'
           unless handler[:command].is_a?(String)
@@ -383,14 +417,14 @@ module Sensu
             end
           end
         when 'set'
-          unless handler[:handlers].is_a?(Array) && handler[:handlers].count > 0
-            invalid('handler set is missing handlers', {
+          unless handler[:handlers].is_a?(Array)
+            invalid('handler set handlers must be an array', {
               :handler => handler
             })
           end
           handler[:handlers].each do |handler_name|
             unless handler_name.is_a?(String)
-              invalid('handler set handlers must be strings', {
+              invalid('handler set handlers items must be strings', {
                 :handler => handler
               })
             end
@@ -400,15 +434,54 @@ module Sensu
             :handler => handler
           })
         end
-      end
-      unless @settings[:mutators].is_a?(Hash)
-        invalid('mutators must be a hash')
-      end
-      mutators.each do |mutator|
-        unless mutator[:command].is_a?(String)
-          invalid('mutator is missing command', {
-            :mutator => mutator
-          })
+        if handler.has_key?(:filter)
+          unless handler[:filter].is_a?(String)
+            invalid('handler filter must be a string', {
+              :handler => handler
+            })
+          end
+        end
+        if handler.has_key?(:filters)
+          unless handler[:filters].is_a?(Array)
+            invalid('handler filters must be an array', {
+              :handler => handler
+            })
+          end
+          handler[:filters].each do |filter_name|
+            unless filter_name.is_a?(String)
+              invalid('handler filters items must be strings', {
+                :handler => handler
+              })
+            end
+          end
+        end
+        if handler.has_key?(:mutator)
+          unless handler[:mutator].is_a?(String)
+            invalid('handler mutator must be a string', {
+              :handler => handler
+            })
+          end
+        end
+        if handler.has_key?(:handle_flapping)
+          unless !!handler[:handle_flapping] == handler[:handle_flapping]
+            invalid('handler handle_flapping must be boolean', {
+              :handler => handler
+            })
+          end
+        end
+        if handler.has_key?(:severities)
+          unless handler[:severities].is_a?(Array) && !handler[:severities].empty?
+            invalid('handler severities must be an array and not empty', {
+              :handler => handler
+            })
+          end
+          handler[:severities].each do |severity|
+            unless Sensu::SEVERITIES.include?(severity)
+              invalid('handler severities are invalid', {
+                :handler => handler
+              })
+            end
+          end
         end
       end
     end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sensu
 version: !ruby/object:Gem::Version 
-  hash: -1732117756
+  hash: 1653984923
   prerelease: true
   segments: 
   - 0
   - 9
   - 9
   - beta
-  version: 0.9.9.beta
+  - 1
+  version: 0.9.9.beta.1
 platform: ruby
 authors: 
 - Sean Porter
@@ -17,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-27 00:00:00 -08:00
+date: 2012-12-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency