sensu 0.25.7 → 0.26.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e1bd8a6afeb2016ff1c3b95dfad080d1f6e13f9
-  data.tar.gz: e2a506b7e5d9868b61dbc546637e6be31829986a
+  metadata.gz: 43dd37a6c04af17e71c851c56ca704a7a074748b
+  data.tar.gz: f5bc129d97ce20cc38aa2011263b5c06378ddd9d
 SHA512:
-  metadata.gz: 64b81f62ec58d7360495020a9180040a3116f88e9f879f48d3b35480a23af0f8b3af47e8f1e0d78b74f53d247aa5ad972a2b0694cd66af78f573c8c76b6baad4
-  data.tar.gz: 362603f315346825d2e1a65f84e509b46c97f2bb0bf6223fcd6cb6c9a860092a4b69bd426a19c3e5fc0275e6dc0365a1bfadde27188156136dfc6a2d7ff900ab
+  metadata.gz: ba486e8272baf979179579d9c4c9f8a66ec88bad4c3c0fd298ed9210aa45e37941429d7cf57a3b4b7a362604ff8d0abb6dbf05c246fa77b51a38070f3b9fba56
+  data.tar.gz: 24cd248e6322595ee191aee1a16bd5903b9d8eff1d0ad9479d337c085470c628752f77260659823d9a602bd0d377914ebcc67ecace581b52c2f6502959dee068

data/CHANGELOG.md

@@ -1,3 +1,50 @@
+## 0.26.0 - TBD
+
+### Fixes
+
+Increased the maximum number of EventMachine timers from 100k to 200k, to
+accommodate very large Sensu installations that execute over 100k checks.
+
+Only attempt to schedule standalone checks that have an interval.
+
+Standalone checks are now long provided by the Sensu API /checks endpoint.
+
+Check TTL events are no longer created if the associated Sensu client has
+a current keepalive event.
+
+Fixed a Sensu API /results endpoint race condition that caused incomplete
+response content.
+
+### Features
+
+Event silencing is now built into Sensu Core! The Sensu API now provides a
+set of /silencing endpoints, for silencing one or more subscriptions
+and/or checks. Silencing applies to all event handlers by default, the new
+handler definition attribute `handle_silenced` can be used to disable it
+for a handler. Metric check events (OK) bypass event silencing.
+
+Subdue now ONLY applies to check scheduling via check definitions, it has
+been removed from handlers (no more `"at": "handler"`). The Sensu client
+standalone check execution scheduler now supports subdue. The subdue
+configuration syntax has changed, please refer to the 0.26 documentation.
+
+Event filters now support time windows, via the filter definition
+attribute `"when": {}`. The configuration syntax is the same as check
+subdue.
+
+Sensu Extensions are now loaded from Rubygems! The Sensu installer,
+`sensu-install`, can now be used to install Sensu Extensions, e.g.
+`sensu-install -e system-profile`. Extensions gems must be enabled via
+Sensu configuration, please refer to the 0.26 documentation.
+
+A check can now be a member of more than one aggregate, via the check
+definition attribute `"aggregates": []`.
+
+Every Sensu client now creates/subscribes to its own unique client
+subscription named after it, e.g. `client:i-424242`. This unique client
+subscription allows Sensu checks to target a single client (host) and
+enables silencing events for a single client.
+
 ## 0.25.7 - 2016-08-09
 
 ### Fixes

data/exe/sensu-install

@@ -8,7 +8,8 @@ module Sensu
       def cli_options(arguments=ARGV)
         options = {
           :verbose => false,
-          :plugins => []
+          :plugins => [],
+          :extensions => []
         }
         optparse = OptionParser.new do |opts|
           opts.on("-h", "--help", "Display this message") do
@@ -24,6 +25,12 @@ module Sensu
           opts.on("-P", "--plugins PLUGIN[,PLUGIN]", "PLUGIN or comma-delimited list of Sensu plugins to install") do |plugins|
             options[:plugins].concat(plugins.split(","))
           end
+          opts.on("-e", "--extension EXTENSION", "Install a Sensu EXTENSION") do |extension|
+            options[:extensions] << extension
+          end
+          opts.on("-E", "--extensions EXTENSION[,EXT]", "EXTENSION or comma-delimited list of Sensu extensions to install") do |extensions|
+            options[:extensions].concat(extensions.split(","))
+          end
           opts.on("-s", "--source SOURCE", "Install Sensu plugins from a custom SOURCE") do |source|
             options[:source] = source
           end
@@ -36,23 +43,23 @@ module Sensu
         puts "[SENSU-INSTALL] #{message}"
       end
 
-      def plugin_gem_installed?(raw_gem, options={})
-        log "determining if Sensu plugin gem '#{raw_gem}' is already installed ..."
+      def gem_installed?(raw_gem, options={})
+        log "determining if Sensu gem '#{raw_gem}' is already installed ..."
         gem_name, gem_version = raw_gem.split(":")
         gem_command = "gem list -i #{gem_name}"
         gem_command << " --version '#{gem_version}'" if gem_version
         log gem_command if options[:verbose]
         if system(gem_command)
-          log "Sensu plugin gem '#{gem_name}' has already been installed"
+          log "Sensu gem '#{gem_name}' has already been installed"
           true
         else
-          log "Sensu plugin gem '#{gem_name}' has not been installed" if options[:verbose]
+          log "Sensu gem '#{gem_name}' has not been installed" if options[:verbose]
           false
         end
       end
 
-      def install_plugin_gem(raw_gem, options={})
-        log "installing Sensu plugin gem '#{raw_gem}'"
+      def install_gem(raw_gem, options={})
+        log "installing Sensu gem '#{raw_gem}'"
         gem_name, gem_version = raw_gem.split(":")
         gem_command = "gem install #{gem_name}"
         gem_command << " --version '#{gem_version}'" if gem_version
@@ -61,7 +68,7 @@ module Sensu
         gem_command << " --source #{options[:source]}" if options[:source]
         log gem_command if options[:verbose]
         unless system(gem_command)
-          log "failed to install Sensu plugin gem '#{gem_name}'"
+          log "failed to install Sensu gem '#{gem_name}'"
           log "you can run the sensu-install command again with --verbose for more info" unless options[:verbose]
           log "please take note of any failure messages above"
           log "make sure you have build tools installed (e.g. gcc)"
@@ -83,21 +90,43 @@ module Sensu
         end
         log "compiled Sensu plugin gems: #{plugin_gems}" if options[:verbose]
         plugin_gems.reject! do |raw_gem|
-          plugin_gem_installed?(raw_gem, options)
+          gem_installed?(raw_gem, options)
         end
         log "Sensu plugin gems to be installed: #{plugin_gems}"
         plugin_gems.each do |raw_gem|
-          install_plugin_gem(raw_gem, options)
+          install_gem(raw_gem, options)
         end
         log "successfully installed Sensu plugins: #{plugins}"
       end
 
+      def install_extensions(extensions, options={})
+        log "installing Sensu extensions ..."
+        log "provided Sensu extensions: #{extensions}" if options[:verbose]
+        extension_gems = extensions.map do |extension|
+          if extension.start_with?("sensu-extensions-")
+            extension
+          else
+            "sensu-extensions-#{extension}"
+          end
+        end
+        log "compiled Sensu extension gems: #{extension_gems}" if options[:verbose]
+        extension_gems.reject! do |raw_gem|
+          gem_installed?(raw_gem, options)
+        end
+        log "Sensu extension gems to be installed: #{extension_gems}"
+        extension_gems.each do |raw_gem|
+          install_gem(raw_gem, options)
+        end
+        log "successfully installed Sensu extensions: #{extensions}"
+      end
+
       def run
         options = cli_options
         unless options[:plugins].empty?
           install_plugins(options[:plugins], options)
-        else
-          log "nothing to do"
+        end
+        unless options[:extensions].empty?
+          install_extensions(options[:extensions], options)
         end
       end
     end

data/lib/sensu/api/http_handler.rb

@@ -95,8 +95,8 @@ module Sensu
           data = Sensu::JSON.load(@http_content)
           valid = data.is_a?(Hash) && rules.all? do |key, rule|
             value = data[key]
-            (value.is_a?(rule[:type]) || (rule[:nil_ok] && value.nil?)) &&
-              (value.nil? || rule[:regex].nil?) ||
+            (Array(rule[:type]).any? {|type| value.is_a?(type)} ||
+              (rule[:nil_ok] && value.nil?)) && (value.nil? || rule[:regex].nil?) ||
               (rule[:regex] && (value =~ rule[:regex]) == 0)
           end
           if valid

data/lib/sensu/api/routes.rb

@@ -8,6 +8,7 @@ require "sensu/api/routes/resolve"
 require "sensu/api/routes/aggregates"
 require "sensu/api/routes/stashes"
 require "sensu/api/routes/results"
+require "sensu/api/routes/silenced"
 
 module Sensu
   module API
@@ -22,6 +23,7 @@ module Sensu
       include Aggregates
       include Stashes
       include Results
+      include Silenced
 
       GET_METHOD = "GET".freeze
       HEAD_METHOD = "HEAD".freeze
@@ -49,7 +51,10 @@ module Sensu
         [STASH_URI, :get_stash],
         [RESULTS_URI, :get_results],
         [RESULTS_CLIENT_URI, :get_results_client],
-        [RESULT_URI, :get_result]
+        [RESULT_URI, :get_result],
+        [SILENCED_URI, :get_silenced],
+        [SILENCED_SUBSCRIPTION_URI, :get_silenced_subscription],
+        [SILENCED_CHECK_URI, :get_silenced_check]
       ]
 
       ROUTES = {
@@ -61,7 +66,9 @@ module Sensu
           [RESOLVE_URI, :post_resolve],
           [STASHES_URI, :post_stashes],
           [STASH_URI, :post_stash],
-          [RESULTS_URI, :post_results]
+          [RESULTS_URI, :post_results],
+          [SILENCED_URI, :post_silenced],
+          [SILENCED_CLEAR_URI, :post_silenced_clear]
         ],
         DELETE_METHOD => [
           [CLIENT_URI, :delete_client],

data/lib/sensu/api/routes/checks.rb

@@ -7,14 +7,14 @@ module Sensu
 
         # GET /checks
         def get_checks
-          @response_content = @settings.checks
+          @response_content = @settings.checks.reject { |check| check[:standalone] }
           respond
         end
 
         # GET /checks/:check_name
         def get_check
           check_name = parse_uri(CHECK_URI).first
-          if @settings[:checks][check_name]
+          if @settings[:checks][check_name] && !@settings[:checks][check_name][:standalone]
             @response_content = @settings[:checks][check_name].merge(:name => check_name)
             respond
           else

data/lib/sensu/api/routes/results.rb

@@ -46,7 +46,9 @@ module Sensu
                       end
                     end
                   elsif client_index == clients.length - 1
-                    respond
+                    @redis.ping do
+                      respond
+                    end
                   end
                 end
               end

data/lib/sensu/api/routes/silenced.rb

@@ -0,0 +1,153 @@
+module Sensu
+  module API
+    module Routes
+      module Silenced
+        SILENCED_URI = /^\/silenced$/
+        SILENCED_SUBSCRIPTION_URI = /^\/silenced\/subscriptions\/([\w\.-]+)$/
+        SILENCED_CHECK_URI = /^\/silenced\/checks\/([\w\.-]+)$/
+        SILENCED_CLEAR_URI = /^\/silenced\/clear$/
+
+        # Fetch silenced registry entries for the provided silenced
+        # entry keys.
+        #
+        # @param silenced_keys [Array]
+        # @yield callback [entries] callback/block called after the
+        #   silenced registry entries have been fetched.
+        def fetch_silenced(silenced_keys=[])
+          entries = []
+          unless silenced_keys.empty?
+            @redis.mget(*silenced_keys) do |silenced|
+              silenced_keys.each_with_index do |silenced_key, silenced_index|
+                if silenced[silenced_index]
+                  silenced_info = Sensu::JSON.load(silenced[silenced_index])
+                  @redis.ttl(silenced_key) do |ttl|
+                    silenced_info[:expire] = ttl
+                    entries << silenced_info
+                    if silenced_index == silenced_keys.length - 1
+                      yield(entries)
+                    end
+                  end
+                else
+                  @redis.srem("silenced", silenced_key)
+                  if silenced_index == silenced_keys.length - 1
+                    @redis.ping do
+                      yield(entries)
+                    end
+                  end
+                end
+              end
+            end
+          else
+            yield(entries)
+          end
+        end
+
+        # POST /silenced
+        def post_silenced
+          rules = {
+            :subscription => {:type => String, :nil_ok => true},
+            :check => {:type => String, :nil_ok => true, :regex => /\A[\w\.-]+\z/},
+            :expire => {:type => Integer, :nil_ok => true},
+            :reason => {:type => String, :nil_ok => true},
+            :creator => {:type => String, :nil_ok => true},
+            :expire_on_resolve => {:type => [TrueClass, FalseClass], :nil_ok => true}
+          }
+          read_data(rules) do |data|
+            if data[:subscription] || data[:check]
+              subscription = data.fetch(:subscription, "*")
+              check = data.fetch(:check, "*")
+              silenced_id = "#{subscription}:#{check}"
+              silenced_info = {
+                :id => silenced_id,
+                :subscription => data[:subscription],
+                :check => data[:check],
+                :reason => data[:reason],
+                :creator => data[:creator],
+                :expire_on_resolve => data.fetch(:expire_on_resolve, false)
+              }
+              silenced_key = "silence:#{silenced_id}"
+              @redis.set(silenced_key, Sensu::JSON.dump(silenced_info)) do
+                @redis.sadd("silenced", silenced_key) do
+                  if data[:expire]
+                    @redis.expire(silenced_key, data[:expire]) do
+                      created!
+                    end
+                  else
+                    created!
+                  end
+                end
+              end
+            else
+              bad_request!
+            end
+          end
+        end
+
+        # GET /silenced
+        def get_silenced
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # GET /silenced/subscriptions/:subscription
+        def get_silenced_subscription
+          subscription = parse_uri(SILENCED_SUBSCRIPTION_URI).first
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys.select! do |key|
+              key =~ /^silence:#{subscription}:/
+            end
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # GET /silenced/checks/:check
+        def get_silenced_check
+          check_name = parse_uri(SILENCED_CHECK_URI).first
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys.select! do |key|
+              key =~ /.*:#{check_name}$/
+            end
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # POST /silenced/clear
+        def post_silenced_clear
+          rules = {
+            :id => {:type => String, :nil_ok => true},
+            :subscription => {:type => String, :nil_ok => true},
+            :check => {:type => String, :nil_ok => true, :regex => /\A[\w\.-]+\z/}
+          }
+          read_data(rules) do |data|
+            if !data[:id].nil? || (data[:subscription] || data[:check])
+              subscription = data.fetch(:subscription, "*")
+              check = data.fetch(:check, "*")
+              silenced_id = data[:id] || "#{subscription}:#{check}"
+              silenced_key = "silence:#{silenced_id}"
+              @redis.srem("silenced", silenced_key) do
+                @redis.del(silenced_key) do |deleted|
+                  deleted ? no_content! : not_found!
+                end
+              end
+            else
+              bad_request!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/client/process.rb

@@ -297,15 +297,20 @@ module Sensu
       # using a calculated execution splay. The timers are stored in
       # the timers hash under `:run`, so they can be cancelled etc.
       # Check definitions are duplicated before processing them, in
-      # case they are mutated. The check `:issued` timestamp is set
-      # here, to mimic check requests issued by a Sensu server.
+      # case they are mutated. A check will not be executed if it is
+      # subdued. The check `:issued` timestamp is set here, to mimic
+      # check requests issued by a Sensu server.
       #
       # @param checks [Array] of definitions.
       def schedule_checks(checks)
         checks.each do |check|
           execute_check = Proc.new do
-            check[:issued] = Time.now.to_i
-            process_check_request(check.dup)
+            unless check_subdued?(check)
+              check[:issued] = Time.now.to_i
+              process_check_request(check.dup)
+            else
+              @logger.info("check execution was subdued", :check => check)
+            end
           end
           execution_splay = testing? ? 0 : calculate_execution_splay(check)
           interval = testing? ? 0.5 : check[:interval]
@@ -318,15 +323,16 @@ module Sensu
 
       # Setup standalone check executions, scheduling standard check
       # definition and check extension executions. Check definitions
-      # and extensions with `:standalone` set to `true` will be
-      # scheduled by the Sensu client for execution.
+      # and extensions with `:standalone` set to `true`, have a
+      # integer `:interval`, and do not have `:publish` set to `false`
+      # will be scheduled by the Sensu client for execution.
       def setup_standalone
         @logger.debug("scheduling standalone checks")
         standard_checks = @settings.checks.select do |check|
-          check[:standalone]
+          check[:standalone] && check[:interval].is_a?(Integer) && check[:publish] != false
         end
         extension_checks = @extensions.checks.select do |check|
-          check[:standalone] && check[:interval].is_a?(Integer)
+          check[:standalone] && check[:interval].is_a?(Integer) && check[:publish] != false
         end
         schedule_checks(standard_checks + extension_checks)
       end

data/lib/sensu/constants.rb

@@ -1,7 +1,7 @@
 module Sensu
   unless defined?(Sensu::VERSION)
     # Sensu release version.
-    VERSION = "0.25.7".freeze
+    VERSION = "0.26.0.beta".freeze
 
     # Sensu check severities.
     SEVERITIES = %w[ok warning critical unknown].freeze

data/lib/sensu/daemon.rb

@@ -4,12 +4,12 @@ gem "eventmachine", "1.2.0.1"
 
 gem "sensu-json", "2.0.0"
 gem "sensu-logger", "1.2.0"
-gem "sensu-settings", "5.2.0"
+gem "sensu-settings", "9.1.0"
 gem "sensu-extension", "1.5.0"
-gem "sensu-extensions", "1.5.0"
+gem "sensu-extensions", "1.7.0"
 gem "sensu-transport", "6.0.0"
 gem "sensu-spawn", "2.2.0"
-gem "sensu-redis", "1.4.0"
+gem "sensu-redis", "1.6.0"
 
 require "time"
 require "uri"
@@ -34,19 +34,21 @@ module Sensu
   module Daemon
     include Utilities
 
-    attr_reader :start_time
+    attr_reader :start_time, :settings
 
     # Initialize the Sensu process. Set the start time, initial
-    # service state, set up the logger, and load settings. This method
-    # will load extensions and setup Sensu Spawn if the Sensu process
-    # is not the Sensu API. This method can and optionally daemonize
-    # the process and/or create a PID file.
+    # service state, double the maximum number of EventMachine timers,
+    # set up the logger, and load settings. This method will load
+    # extensions and setup Sensu Spawn if the Sensu process is not the
+    # Sensu API. This method can and optionally daemonize the process
+    # and/or create a PID file.
     #
     # @param options [Hash]
     def initialize(options={})
       @start_time = Time.now.to_i
       @state = :initializing
       @timers = {:run => []}
+      EM::set_max_timers(200000) unless EM::reactor_running?
       setup_logger(options)
       load_settings(options)
       unless sensu_service_name == "api"
@@ -148,7 +150,8 @@ module Sensu
     #
     # @param options [Hash]
     def load_extensions(options={})
-      @extensions = Extensions.get(options)
+      extensions_options = options.merge(:extensions => @settings[:extensions])
+      @extensions = Extensions.get(extensions_options)
       log_notices(@extensions.warnings)
       extension_settings = @settings.to_hash.dup
       @extensions.all.each do |extension|

data/lib/sensu/server/filter.rb

@@ -5,112 +5,13 @@ module Sensu
     module Filter
       EVAL_PREFIX = "eval:".freeze
 
-      # Determine if a period of time (window) is subdued. The
-      # provided condition must have a `:begin` and `:end` time, eg.
-      # "11:30:00 PM", or `false` will be returned.
-      #
-      # @param condition [Hash]
-      # @option condition [String] :begin time.
-      # @option condition [String] :end time.
-      # @return [TrueClass, FalseClass]
-      def subdue_time?(condition)
-        if condition.has_key?(:begin) && condition.has_key?(:end)
-          begin_time = Time.parse(condition[:begin])
-          end_time = Time.parse(condition[:end])
-          if end_time < begin_time
-            if Time.now < end_time
-              begin_time = Time.parse("12:00:00 AM")
-            else
-              end_time = Time.parse("11:59:59 PM")
-            end
-          end
-          Time.now >= begin_time && Time.now <= end_time
-        else
-          false
-        end
-      end
-
-      # Determine if the current day is subdued. The provided
-      # condition must have a list of `:days`, or false will be
-      # returned.
-      #
-      # @param condition [Hash]
-      # @option condition [Array] :days of the week to subdue.
-      # @return [TrueClass, FalseClass]
-      def subdue_days?(condition)
-        if condition.has_key?(:days)
-          days = condition[:days].map(&:downcase)
-          days.include?(Time.now.strftime("%A").downcase)
-        else
-          false
-        end
-      end
-
-      # Determine if there is an exception a period of time (window)
-      # that is subdued. The provided condition must have an
-      # `:exception`, containing one or more `:begin` and `:end`
-      # times, eg. "11:30:00 PM", or `false` will be returned. If
-      # there are any exceptions to a subdued period of time, `true`
-      # will be returned.
-      #
-      # @param condition [Hash]
-      # @option condition [Hash] :exceptions array of `:begin` and
-      #   `:end` times.
-      # @return [TrueClass, FalseClass]
-      def subdue_exception?(condition)
-        if condition.has_key?(:exceptions)
-          condition[:exceptions].any? do |exception|
-            Time.now >= Time.parse(exception[:begin]) && Time.now <= Time.parse(exception[:end])
-          end
-        else
-          false
-        end
-      end
-
-      # Determine if an action is subdued and if there is an
-      # exception. This method makes use of `subdue_time?()`,
-      # `subdue_days?()`, and subdue_exception?().
-      #
-      # @param condition [Hash]
-      # @return [TrueClass, FalseClass]
-      def action_subdued?(condition)
-        subdued = subdue_time?(condition) || subdue_days?(condition)
-        subdued && !subdue_exception?(condition)
-      end
-
-      # Determine if an event handler is subdued, by conditions set in
-      # the check and/or the handler definition. If any of the
-      # conditions are true, without an exception, the handler is
-      # subdued.
+      # Determine if an event handler is silenced.
       #
       # @param handler [Hash] definition.
-      # @param event [Hash] data possibly containing subdue
-      #   conditions.
-      # @return [TrueClass, FalseClass]
-      def handler_subdued?(handler, event)
-        subdued = []
-        if handler[:subdue]
-          subdued << action_subdued?(handler[:subdue])
-        end
-        check = event[:check]
-        if check[:subdue] && check[:subdue][:at] != "publisher"
-          subdued << action_subdued?(check[:subdue])
-        end
-        subdued.any?
-      end
-
-      # Determine if a check request is subdued, by conditions set in
-      # the check definition. If any of the conditions are true,
-      # without an exception, the check request is subdued.
-      #
-      # @param check [Hash] definition.
+      # @param event [Hash]
       # @return [TrueClass, FalseClass]
-      def check_request_subdued?(check)
-        if check[:subdue] && check[:subdue][:at] == "publisher"
-          action_subdued?(check[:subdue])
-        else
-          false
-        end
+      def handler_silenced?(handler, event)
+        event[:silenced] && !handler[:handle_silenced]
       end
 
       # Determine if handling is disabled for an event. Check
@@ -257,13 +158,64 @@ module Sensu
         end
       end
 
-      # Determine if an event is filtered by an event filter, standard
+      # Determine if a filter is to be evoked for the current time. A
+      # filter can be configured with a time window defining when it
+      # is to be evoked, e.g. Monday through Friday, 9-5.
+      #
+      # @param filter [Hash] definition.
+      # @return [TrueClass, FalseClass]
+      def in_filter_time_windows?(filter)
+        if filter[:when]
+          in_time_windows?(filter[:when])
+        else
+          true
+        end
+      end
+
+      # Determine if an event is filtered by a native filter.
+      #
+      # @param filter_name [String]
+      # @param event [Hash]
+      # @yield [filtered] callback/block called with a single
+      #   parameter to indicate if the event was filtered.
+      # @yieldparam filtered [TrueClass,FalseClass] indicating if the
+      #   event was filtered.
+      def native_filter(filter_name, event)
+        filter = @settings[:filters][filter_name]
+        if in_filter_time_windows?(filter)
+          matched = filter_attributes_match?(event, filter[:attributes])
+          yield(filter[:negate] ? matched : !matched)
+        else
+          yield(false)
+        end
+      end
+
+      # Determine if an event is filtered by a filter extension.
+      #
+      # @param filter_name [String]
+      # @param event [Hash]
+      # @yield [filtered] callback/block called with a single
+      #   parameter to indicate if the event was filtered.
+      # @yieldparam filtered [TrueClass,FalseClass] indicating if the
+      #   event was filtered.
+      def extension_filter(filter_name, event)
+        extension = @extensions[:filters][filter_name]
+        if in_filter_time_windows?(extension.definition)
+          extension.safe_run(event) do |output, status|
+            yield(status == 0)
+          end
+        else
+          yield(false)
+        end
+      end
+
+      # Determine if an event is filtered by an event filter, native
       # or extension. This method first checks for the existence of a
-      # standard filter, then checks for an extension if a standard
-      # filter is not defined. The provided callback is called with a
-      # single parameter, indicating if the event was filtered by a
-      # filter. If a filter does not exist for the provided name, the
-      # event is not filtered.
+      # native filter, then checks for an extension if a native filter
+      # is not defined. The provided callback is called with a single
+      # parameter, indicating if the event was filtered by a filter.
+      # If a filter does not exist for the provided name, the event is
+      # not filtered.
       #
       # @param filter_name [String]
       # @param event [Hash]
@@ -274,13 +226,12 @@ module Sensu
       def event_filter(filter_name, event)
         case
         when @settings.filter_exists?(filter_name)
-          filter = @settings[:filters][filter_name]
-          matched = filter_attributes_match?(event, filter[:attributes])
-          yield(filter[:negate] ? matched : !matched)
+          native_filter(filter_name, event) do |filtered|
+            yield(filtered)
+          end
         when @extensions.filter_exists?(filter_name)
-          extension = @extensions[:filters][filter_name]
-          extension.safe_run(event) do |output, status|
-            yield(status == 0)
+          extension_filter(filter_name, event) do |filtered|
+            yield(filtered)
           end
         else
           @logger.error("unknown filter", :filter_name => filter_name)
@@ -340,8 +291,8 @@ module Sensu
           "handler does not handle action"
         when !handle_severity?(handler, event)
           "handler does not handle event severity"
-        when handler_subdued?(handler, event)
-          "handler is subdued"
+        when handler_silenced?(handler, event)
+          "handler is silenced"
         end
         if filter_message
           @logger.info(filter_message, details)

data/lib/sensu/server/process.rb

@@ -275,26 +275,37 @@ module Sensu
         end
       end
 
-      # Add a check result to an aggregate. The aggregate name is
-      # determined by the value of check `:aggregate`. If check
-      # `:aggregate` is `true` (legacy), the check `:name` is used as
-      # the aggregate name. If check `:aggregate` is a string, it is
-      # used as the aggregate name. This method will add the client
-      # name to the aggregate, all other processing (e.g. counters) is
-      # done by the Sensu API on request.
+      # Add a check result to one or more aggregates. The aggregate name is
+      # determined by the value of check `:aggregates` array, if present,
+      # and falling back to `:aggregate` otherwise.
+      #
+      # When one or more aggregates are specified as `:aggregates`, the
+      # client name and check are updated on each aggregate.
+      #
+      # When no aggregates are specified as `:aggregates`, and `:aggregate`
+      # is `true` (legacy), the check `:name` is used as the aggregate name.
+      #
+      # When no aggregates are specified as `:aggregates` and check `:aggregate`
+      # is a string, it used as the aggregate name.
+      #
+      # This method will add the client name to configured aggregates, all
+      # other processing (e.g. counters) is done by the Sensu API on request.
       #
       # @param client [Hash]
       # @param check [Hash]
       def aggregate_check_result(client, check)
-        aggregate = (check[:aggregate].is_a?(String) ? check[:aggregate] : check[:name])
-        @logger.debug("adding check result to aggregate", {
-          :aggregate => aggregate,
-          :client => client,
-          :check => check
-        })
-        aggregate_member = "#{client[:name]}:#{check[:name]}"
-        @redis.sadd("aggregates:#{aggregate}", aggregate_member) do
-          @redis.sadd("aggregates", aggregate)
+        check_aggregate = (check[:aggregate].is_a?(String) ? check[:aggregate] : check[:name])
+        aggregate_list = Array(check[:aggregates] || check_aggregate)
+        aggregate_list.each do |aggregate|
+          @logger.debug("adding check result to aggregate", {
+            :aggregate => aggregate,
+            :client => client,
+            :check => check
+          })
+          aggregate_member = "#{client[:name]}:#{check[:name]}"
+          @redis.sadd("aggregates:#{aggregate}", aggregate_member) do
+            @redis.sadd("aggregates", aggregate)
+          end
         end
       end
 
@@ -414,6 +425,50 @@ module Sensu
         end
       end
 
+      # Determine if an event has been silenced. This method compiles
+      # an array of possible silenced registry entry keys for the
+      # event. An attempt is made to fetch one or more of the silenced
+      # registry entries to determine if the event has been silenced.
+      # The event data is updated to indicate if the event has been
+      # silenced. If the event is silenced and the event action is
+      # `:resolve`, silenced registry entries with
+      # `:expire_on_resolve` set to true will be deleted. Silencing is
+      # disabled for events with a check status of `0` (OK), unless
+      # the event action is `:resolve` or `:flapping`.
+      #
+      # @param event [Hash]
+      # @yield callback [event] callback/block called after the event
+      #   data has been updated to indicate if it has been silenced.
+      def event_silenced?(event)
+        event[:silenced] = false
+        event[:silenced_by] = []
+        if event[:check][:status] != 0 || event[:action] != :create
+          check_name = event[:check][:name]
+          silenced_keys = event[:client][:subscriptions].map { |subscription|
+            ["silence:#{subscription}:*", "silence:#{subscription}:#{check_name}"]
+          }.flatten
+          silenced_keys << "silence:*:#{check_name}"
+          @redis.mget(*silenced_keys) do |silenced|
+            silenced.compact!
+            event[:silenced] = !silenced.empty?
+            if event[:silenced]
+              silenced.each do |silenced_json|
+                silenced_info = Sensu::JSON.load(silenced_json)
+                event[:silenced_by] << silenced_info[:id]
+                silenced_key = "silence:#{silenced_info[:id]}"
+                if silenced_info[:expire_on_resolve] && event[:action] == :resolve
+                  @redis.srem("silenced", silenced_key)
+                  @redis.del(silenced_key)
+                end
+              end
+            end
+            yield(event)
+          end
+        else
+          yield(event)
+        end
+      end
+
       # Update the event registry, stored in Redis. This method
       # determines if event data warrants in the creation or update of
       # event data in the registry. If a check `:status` is not
@@ -451,7 +506,8 @@ module Sensu
       # Create an event, using the provided client and check result
       # data. Existing event data for the client/check pair is fetched
       # from the event registry to be used in the composition of the
-      # new event.
+      # new event. The silenced registry is used to determine if the
+      # event has been silenced.
       #
       # @param client [Hash]
       # @param check [Hash]
@@ -469,6 +525,7 @@ module Sensu
               :client => client,
               :check => check,
               :occurrences => 1,
+              :occurrences_watermark => 1,
               :action => (flapping ? :flapping : :create),
               :timestamp => Time.now.to_i
             }
@@ -477,12 +534,17 @@ module Sensu
               event[:last_state_change] = stored_event[:last_state_change]
               event[:last_ok] = stored_event[:last_ok]
               event[:occurrences] = stored_event[:occurrences]
+              event[:occurrences_watermark] = stored_event[:occurrences_watermark] || event[:occurrences]
             else
               event[:id] = random_uuid
+              event[:last_ok] = event[:timestamp]
             end
             if check[:status] != 0 || flapping
               if history[-1] == history[-2]
                 event[:occurrences] += 1
+                if event[:occurrences] > event[:occurrences_watermark]
+                  event[:occurrences_watermark] = event[:occurrences]
+                end
               else
                 event[:occurrences] = 1
                 event[:last_state_change] = event[:timestamp]
@@ -494,7 +556,9 @@ module Sensu
             if check[:status] == 0
               event[:last_ok] = event[:timestamp]
             end
-            yield(event)
+            event_silenced?(event) do |event|
+              yield(event)
+            end
           end
         end
       end
@@ -555,6 +619,16 @@ module Sensu
         end
       end
 
+      # Determine if a keepalive event exists for a client.
+      #
+      # @param client_name [String] name of client to look up in event registry.
+      # @return [TrueClass, FalseClass]
+      def keepalive_event_exists?(client_name)
+        @redis.hexists("events:#{client_name}", "keepalive") do |event_exists|
+          yield(event_exists)
+        end
+      end
+
       # Process a check result, storing its data, inspecting its
       # contents, and taking the appropriate actions (eg. update the
       # event registry). The `@in_progress[:check_results]` counter is
@@ -579,7 +653,7 @@ module Sensu
           end
           check[:type] ||= STANDARD_CHECK_TYPE
           check[:origin] = result[:client] if check[:source]
-          aggregate_check_result(client, check) if check[:aggregate]
+          aggregate_check_result(client, check) if check[:aggregates] || check[:aggregate]
           store_check_result(client, check) do
             create_event(client, check) do |event|
               event_bridges(event)
@@ -693,7 +767,7 @@ module Sensu
       def schedule_check_executions(checks)
         checks.each do |check|
           create_check_request = Proc.new do
-            unless check_request_subdued?(check)
+            unless check_subdued?(check)
               publish_check_request(check)
             else
               @logger.info("check request was subdued", :check => check)
@@ -877,10 +951,14 @@ module Sensu
                 time_since_last_execution = Time.now.to_i - check[:executed]
                 if time_since_last_execution >= check[:ttl]
                   client_name = result_key.split(":").first
-                  check[:output] = "Last check execution was "
-                  check[:output] << "#{time_since_last_execution} seconds ago"
-                  check[:status] = 1
-                  publish_check_result(client_name, check)
+                  keepalive_event_exists?(client_name) do |event_exists|
+                    unless event_exists
+                      check[:output] = "Last check execution was "
+                      check[:output] << "#{time_since_last_execution} seconds ago"
+                      check[:status] = 1
+                      publish_check_result(client_name, check)
+                    end
+                  end
                 end
               else
                 @redis.srem("ttl", result_key)

data/lib/sensu/utilities.rb

@@ -118,5 +118,69 @@ module Sensu
       end
       [substituted, unmatched_tokens]
     end
+
+    # Determine if the current time falls within a time window. The
+    # provided condition must have a `:begin` and `:end` time, eg.
+    # "11:30:00 PM", or `false` will be returned.
+    #
+    # @param condition [Hash]
+    # @option condition [String] :begin time.
+    # @option condition [String] :end time.
+    # @return [TrueClass, FalseClass]
+    def in_time_window?(condition)
+      if condition.has_key?(:begin) && condition.has_key?(:end)
+        begin_time = Time.parse(condition[:begin])
+        end_time = Time.parse(condition[:end])
+        if end_time < begin_time
+          if Time.now < end_time
+            begin_time = Time.parse("12:00:00 AM")
+          else
+            end_time = Time.parse("11:59:59 PM")
+          end
+        end
+        Time.now >= begin_time && Time.now <= end_time
+      else
+        false
+      end
+    end
+
+    # Determine if time window conditions for one or more days of the
+    # week are met. If a day of the week is provided, it can provide
+    # one or more conditions, each with a `:begin` and `:end` time,
+    # eg. "11:30:00 PM", or `false` will be returned.
+    #
+    # @param conditions [Hash]
+    # @option conditions [String] :days of the week.
+    # @return [TrueClass, FalseClass]
+    def in_time_windows?(conditions)
+      in_window = false
+      window_days = conditions[:days] || {}
+      if window_days[:all]
+        in_window = window_days[:all].any? do |condition|
+          in_time_window?(condition)
+        end
+      end
+      current_day = Time.now.strftime("%A").downcase.to_sym
+      if !in_window && window_days[current_day]
+        in_window = window_days[current_day].any? do |condition|
+          in_time_window?(condition)
+        end
+      end
+      in_window
+    end
+
+    # Determine if a check is subdued, by conditions set in the check
+    # definition. If any of the conditions are true, without an
+    # exception, the check is subdued.
+    #
+    # @param check [Hash] definition.
+    # @return [TrueClass, FalseClass]
+    def check_subdued?(check)
+      if check[:subdue]
+        in_time_windows?(check[:subdue])
+      else
+        false
+      end
+    end
   end
 end

data/sensu.gemspec

@@ -15,12 +15,12 @@ Gem::Specification.new do |s|
   s.add_dependency "eventmachine", "1.2.0.1"
   s.add_dependency "sensu-json", "2.0.0"
   s.add_dependency "sensu-logger", "1.2.0"
-  s.add_dependency "sensu-settings", "5.2.0"
+  s.add_dependency "sensu-settings", "9.1.0"
   s.add_dependency "sensu-extension", "1.5.0"
-  s.add_dependency "sensu-extensions", "1.5.0"
+  s.add_dependency "sensu-extensions", "1.7.0"
   s.add_dependency "sensu-transport", "6.0.0"
   s.add_dependency "sensu-spawn", "2.2.0"
-  s.add_dependency "sensu-redis", "1.4.0"
+  s.add_dependency "sensu-redis", "1.6.0"
   s.add_dependency "em-http-server", "0.1.8"
 
   s.add_development_dependency "rake", "10.5.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sensu
 version: !ruby/object:Gem::Version
-  version: 0.25.7
+  version: 0.26.0.beta
 platform: ruby
 authors:
 - Sean Porter
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 9.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 9.1.0
 - !ruby/object:Gem::Dependency
   name: sensu-extension
   requirement: !ruby/object:Gem::Requirement
@@ -87,14 +87,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: sensu-transport
   requirement: !ruby/object:Gem::Requirement
@@ -129,14 +129,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: em-http-server
   requirement: !ruby/object:Gem::Requirement
@@ -239,6 +239,7 @@ files:
 - lib/sensu/api/routes/request.rb
 - lib/sensu/api/routes/resolve.rb
 - lib/sensu/api/routes/results.rb
+- lib/sensu/api/routes/silenced.rb
 - lib/sensu/api/routes/stashes.rb
 - lib/sensu/api/utilities/publish_check_request.rb
 - lib/sensu/api/utilities/publish_check_result.rb
@@ -274,9 +275,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.3