sensu 0.27.1 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 848a4443459327c245760df5a5845eb525c0f764
-  data.tar.gz: 747c00aa13b824942c83c1d9970ffdc2d922aae3
+  metadata.gz: 36cc218210482434f3c8fd4e27e662d109f336f6
+  data.tar.gz: 25fd707fa69a6228cd9979e80d726facb8d4325b
 SHA512:
-  metadata.gz: 15d626cff0c140b0cad61db37d810c7d4a535c85e938c73b0e12baf31c01bb7850246867c5886e63099308f776754962f6ba03843a6aae19c8580197dc1e4c96
-  data.tar.gz: da0a760f6bb3ebf0ba1832387e6ff2ea84202692f10dab35e03ce06fbdcddf31bd8a8e5230b22b93f9b002303f5b16589f8a3de5ed5aa85050ed5bb01cccb70c
+  metadata.gz: d16c1695e58f06722efb401f28759ce0b187bd66893e371eaf9e6e6f3df1d4d55b2c1c943de0e53334f09e8a678677b8ec7b5d94ba083bd3c288c7c46cd68dc3
+  data.tar.gz: fe9d61057a7d5914b8c8dd901d0bb4630783fcf21b0bd48befa1f07abe8b1e38bc1c23672321baa870bdd46260968c798104970bbd7eb0b45236be5d29bfb947

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+## 0.28.0 - 2017-02-23
+
+### Features
+
+Added proxy check requests to improve Sensu's ability to monitor external
+resources that have an associated Sensu proxy client. Publish a check
+request to the configured `subscribers` (e.g.
+`["round-robin:snmp_pollers"]`) for every Sensu client in the registry
+that matches the configured client attributes in `client_attributes` on
+the configured `interval` (e.g. `60`). Client tokens in the check
+definition (e.g. `"check-snmp-if.rb -h :::address::: -i eth0"`) are
+substituted prior to publishing the check request. The check request check
+`source` is set to the client `name`.
+
+Schedule check requests and standalone executions with the Cron syntax.
+
+Added the Sensu server registry, containing information about the running
+Sensu servers. Information about the Sensu servers is now accessible via
+the Sensu API `/info` endpoint.
+
+Added two optional attributes to Sensu API POST `/request`, `"reason"` and
+`"creator"`, for additional context. The check request reason and creator
+are added to the check request payload under `"api_requested"` and become
+part of the check result.
+
+Added event IDs to event handler log events for additional context, making
+it easier to trace an event through the Sensu pipeline.
+
+### Fixes
+
+The Sensu interval timers, used for scheduling tasks, now account for
+drift. The check request and standalone execution scheduler timers are now
+more accurate.
+
+Fixed a bug in the Sensu `deep_merge()` method that was responsible for
+mutating arrays of the original provided objects.
+
 ## 0.27.1 - 2017-02-17
 
 ### Other

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

@@ -137,7 +137,7 @@ module Sensu
                         end
                       end
                     else
-                      EM::Timer.new(1) do
+                      Timer.new(1) do
                         delete_client.call(attempts)
                       end
                     end

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

@@ -1,26 +1,31 @@
 require "sensu/api/utilities/transport_info"
+require "sensu/api/utilities/servers_info"
 
 module Sensu
   module API
     module Routes
       module Info
         include Utilities::TransportInfo
+        include Utilities::ServersInfo
 
         INFO_URI = /^\/info$/
 
         # GET /info
         def get_info
-          transport_info do |info|
-            @response_content = {
-              :sensu => {
-                :version => VERSION
-              },
-              :transport => info,
-              :redis => {
-                :connected => @redis.connected?
+          transport_info do |transport|
+            servers_info do |servers|
+              @response_content = {
+                :sensu => {
+                  :version => VERSION
+                },
+                :transport => transport,
+                :redis => {
+                  :connected => @redis.connected?
+                },
+                :servers => servers
               }
-            }
-            respond
+              respond
+            end
           end
         end
       end

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

@@ -12,7 +12,9 @@ module Sensu
         def post_request
           rules = {
             :check => {:type => String, :nil_ok => false},
-            :subscribers => {:type => Array, :nil_ok => true}
+            :subscribers => {:type => Array, :nil_ok => true},
+            :reason => {:type => String, :nil_ok => true},
+            :creator => {:type => String, :nil_ok => true}
           }
           read_data(rules) do |data|
             if @settings[:checks][data[:check]]
@@ -20,6 +22,10 @@ module Sensu
               check[:name] = data[:check]
               check[:subscribers] ||= Array.new
               check[:subscribers] = data[:subscribers] if data[:subscribers]
+              check[:api_requested] = {
+                :reason => data[:reason],
+                :creator => data[:creator]
+              }
               publish_check_request(check)
               @response_content = {:issued => Time.now.to_i}
               accepted!

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

@@ -64,7 +64,8 @@ module Sensu
                 :check => data[:check],
                 :reason => data[:reason],
                 :creator => data[:creator],
-                :expire_on_resolve => data.fetch(:expire_on_resolve, false)
+                :expire_on_resolve => data.fetch(:expire_on_resolve, false),
+                :timestamp => Time.now.to_i
               }
               silenced_key = "silence:#{silenced_id}"
               @redis.set(silenced_key, Sensu::JSON.dump(silenced_info)) do

data/lib/sensu/api/utilities/servers_info.rb

@@ -0,0 +1,36 @@
+module Sensu
+  module API
+    module Utilities
+      module ServersInfo
+        # Retreive the Sensu servers info.
+        #
+        # @yield [Hash] passes servers info to the callback/block.
+        def servers_info
+          info = []
+          if @redis.connected?
+            @redis.smembers("servers") do |servers|
+              unless servers.empty?
+                servers.each_with_index do |server_id, index|
+                  @redis.get("server:#{server_id}") do |server_json|
+                    unless server_json.nil?
+                      info << Sensu::JSON.load(server_json)
+                    else
+                      @redis.srem("servers", server_id)
+                    end
+                    if index == servers.length - 1
+                      yield(info)
+                    end
+                  end
+                end
+              else
+                yield(info)
+              end
+            end
+          else
+            yield(info)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/utilities/transport_info.rb

@@ -9,6 +9,7 @@ module Sensu
         # @yield [Hash] passes Transport info to the callback/block.
         def transport_info
           info = {
+            :name => @settings[:transport][:name],
             :keepalives => {
               :messages => nil,
               :consumers => nil

data/lib/sensu/client/process.rb

@@ -69,7 +69,7 @@ module Sensu
       def setup_keepalives
         @logger.debug("scheduling keepalives")
         publish_keepalive
-        @timers[:run] << EM::PeriodicTimer.new(20) do
+        @timers[:run] << PeriodicTimer.new(20) do
           publish_keepalive
         end
       end
@@ -100,33 +100,6 @@ module Sensu
         end
       end
 
-      # Perform token substitution for an object. String values are
-      # passed to `substitute_tokens()`, arrays and sub-hashes are
-      # processed recursively. Numeric values are ignored.
-      #
-      # @param object [Object]
-      # @return	[Array] containing the updated object with substituted
-      #   values and an array of unmatched tokens.
-      def object_substitute_tokens(object)
-        unmatched_tokens = []
-        case object
-        when Hash
-          object.each do |key, value|
-            object[key], unmatched = object_substitute_tokens(value)
-            unmatched_tokens.push(*unmatched)
-          end
-        when Array
-          object.map! do |value|
-            value, unmatched = object_substitute_tokens(value)
-            unmatched_tokens.push(*unmatched)
-            value
-          end
-        when String
-          object, unmatched_tokens = substitute_tokens(object, @settings[:client])
-        end
-        [object, unmatched_tokens.uniq]
-      end
-
       # Execute a check command, capturing its output (STDOUT/ERR),
       # exit status code, execution duration, timestamp, and publish
       # the result. This method guards against multiple executions for
@@ -144,7 +117,7 @@ module Sensu
         @logger.debug("attempting to execute check command", :check => check)
         unless @checks_in_progress.include?(check[:name])
           @checks_in_progress << check[:name]
-          substituted, unmatched_tokens = object_substitute_tokens(check.dup)
+          substituted, unmatched_tokens = object_substitute_tokens(check.dup, @settings[:client])
           check = substituted.merge(:command => check[:command])
           started = Time.now.to_f
           check[:executed] = started.to_i
@@ -292,58 +265,102 @@ module Sensu
         end
       end
 
+      # Create a check execution proc, used to execute standalone
+      # checks. Checks are not executed if subdued. The check
+      # `:issued` timestamp is set here, to mimic check requests
+      # issued by a Sensu server. Check definitions are duplicated
+      # before processing them, in case they are mutated.
+      #
+      # @param check [Hash] definition.
+      def create_check_execution_proc(check)
+        Proc.new do
+          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
+      end
+
+      # Schedule a check execution, using the check cron. This method
+      # determines the time until the next cron time (in seconds) and
+      # creats an EventMachine timer for the execution. This method
+      # will be called after every check cron execution for subsequent
+      # executions. The timer is stored in the timers hash under
+      # `:run`, so it can be cancelled etc. The check cron execution
+      # timer object is removed from the timer hash after the
+      # execution, to stop the timer hash from growing infinitely.
+      #
+      # @param check [Hash] definition.
+      def schedule_check_cron_execution(check)
+        cron_time = determine_check_cron_time(check)
+        @timers[:run] << Timer.new(cron_time) do |timer|
+          create_check_execution_proc(check).call
+          @timers[:run].delete(timer)
+          schedule_check_cron_execution(check)
+        end
+      end
+
       # Calculate a check execution splay, taking into account the
       # current time and the execution interval to ensure it's
       # consistent between process restarts.
       #
       # @param check [Hash] definition.
-      def calculate_execution_splay(check)
+      def calculate_check_execution_splay(check)
         key = [@settings[:client][:name], check[:name]].join(":")
         splay_hash = Digest::MD5.digest(key).unpack("Q<").first
         current_time = (Time.now.to_f * 1000).to_i
         (splay_hash - current_time) % (check[:interval] * 1000) / 1000.0
       end
 
-      # Schedule check executions, using EventMachine periodic timers,
-      # 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. 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.
+      # Schedule check executions, using the check interval. This
+      # method using an intial calculated execution splay EventMachine
+      # timer and an EventMachine periodic timer for subsequent check
+      # executions. The timers are stored in the timers hash under
+      # `:run`, so they can be cancelled etc.
+      #
+      # @param check [Hash] definition.
+      def schedule_check_interval_executions(check)
+        execution_splay = testing? ? 0 : calculate_check_execution_splay(check)
+        interval = testing? ? 0.5 : check[:interval]
+        @timers[:run] << Timer.new(execution_splay) do
+          execute_check = create_check_execution_proc(check)
+          execute_check.call
+          @timers[:run] << PeriodicTimer.new(interval, &execute_check)
+        end
+      end
+
+      # Schedule check executions. This method iterates through defined
+      # checks and uses the appropriate method of check execution
+      # scheduling, either with the cron syntax or a numeric interval.
       #
       # @param checks [Array] of definitions.
       def schedule_checks(checks)
         checks.each do |check|
-          execute_check = Proc.new do
-            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]
-          @timers[:run] << EM::Timer.new(execution_splay) do
-            execute_check.call
-            @timers[:run] << EM::PeriodicTimer.new(interval, &execute_check)
+          if check[:cron]
+            schedule_check_cron_execution(check)
+          else
+            schedule_check_interval_executions(check)
           end
         end
       end
 
       # Setup standalone check executions, scheduling standard check
       # definition and check extension executions. Check definitions
-      # 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.
+      # and extensions with `:standalone` set to `true`, do not have
+      # `:publish` set to `false`, and have a integer `:interval` or a
+      # string `cron` 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[:interval].is_a?(Integer) && check[:publish] != false
+          check[:standalone] && check[:publish] != false &&
+            (check[:interval].is_a?(Integer) || check[:cron].is_a?(String))
         end
         extension_checks = @extensions.checks.select do |check|
-          check[:standalone] && check[:interval].is_a?(Integer) && check[:publish] != false
+          check[:standalone] && check[:publish] != false &&
+            (check[:interval].is_a?(Integer) || check[:cron].is_a?(String))
         end
         schedule_checks(standard_checks + extension_checks)
       end

data/lib/sensu/client/socket.rb

@@ -106,7 +106,7 @@ module Sensu
       # Reset (or start) the connection watchdog.
       def reset_watchdog
         cancel_watchdog
-        @watchdog = EM::Timer.new(WATCHDOG_DELAY) do
+        @watchdog = Timer.new(WATCHDOG_DELAY) do
           @mode = MODE_REJECT
           @logger.warn("discarding data buffer for sender and closing connection", {
             :data => @data_buffer,

data/lib/sensu/constants.rb

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

data/lib/sensu/daemon.rb

@@ -4,7 +4,7 @@ gem "eventmachine", "1.2.2"
 
 gem "sensu-json", "2.0.1"
 gem "sensu-logger", "1.2.1"
-gem "sensu-settings", "9.8.0"
+gem "sensu-settings", "9.9.0"
 gem "sensu-extension", "1.5.1"
 gem "sensu-extensions", "1.7.1"
 gem "sensu-transport", "7.0.2"
@@ -18,6 +18,7 @@ if RUBY_PLATFORM =~ /aix/ || RUBY_PLATFORM =~ /solaris/
   require "em/pure_ruby"
 end
 
+require "sensu/timers"
 require "sensu/json"
 require "sensu/logger"
 require "sensu/settings"
@@ -227,7 +228,7 @@ module Sensu
           @signals << signal
         end
       end
-      EM::PeriodicTimer.new(1) do
+      PeriodicTimer.new(1) do
         signal = @signals.shift
         if STOP_SIGNALS.include?(signal)
           @logger.warn("received signal", :signal => signal)

data/lib/sensu/sandbox.rb

@@ -0,0 +1,19 @@
+module Sensu
+  module Sandbox
+    # Evaluate a Ruby expression within the context of a simple
+    # "sandbox", a Proc in a module method. As of Ruby 2.3.0,
+    # `$SAFE` no longer supports levels > 1, so its use has been
+    # removed from this method. A single value is provided to the
+    # "sandbox".
+    #
+    # @param expression [String] to be evaluated.
+    # @param value [Object] to provide the "sandbox" with.
+    # @return [Object]
+    def self.eval(expression, value=nil)
+      result = Proc.new do
+        Kernel.eval(expression)
+      end
+      result.call
+    end
+  end
+end

data/lib/sensu/server/filter.rb

@@ -1,10 +1,6 @@
-require "sensu/server/sandbox"
-
 module Sensu
   module Server
     module Filter
-      EVAL_PREFIX = "eval:".freeze
-
       # Determine if an event handler is silenced.
       #
       # @param handler [Hash] definition.
@@ -68,96 +64,6 @@ module Sensu
         end
       end
 
-      # Process a filter eval attribute, a Ruby `eval()` string
-      # containing an expression to be evaluated within the
-      # scope/context of a sandbox. This methods strips away the
-      # expression prefix, `eval:`, and substitues any dot notation
-      # tokens with the corresponding event data values. If there are
-      # unmatched tokens, this method will return `nil`.
-      #
-      # @event [Hash]
-      # @raw_eval_string [String]
-      # @return [String] processed eval string.
-      def process_eval_string(event, raw_eval_string)
-        eval_string = raw_eval_string.slice(5..-1)
-        eval_string, unmatched_tokens = substitute_tokens(eval_string, event)
-        if unmatched_tokens.empty?
-          eval_string
-        else
-          @logger.error("filter eval unmatched tokens", {
-            :raw_eval_string => raw_eval_string,
-            :unmatched_tokens => unmatched_tokens,
-            :event => event
-          })
-          nil
-        end
-      end
-
-      # Ruby `eval()` a string containing an expression, within the
-      # scope/context of a sandbox. This method is for filter
-      # attribute values starting with "eval:", with the Ruby
-      # expression following the colon. A single variable is provided
-      # to the expression, `value`, equal to the corresponding event
-      # attribute value. Dot notation tokens in the expression, e.g.
-      # `:::mysql.user:::`, are substituted with the corresponding
-      # event data values prior to evaluation. The expression is
-      # expected to return a boolean value.
-      #
-      # @param event [Hash]
-      # @param raw_eval_string [String] containing the Ruby
-      #   expression to be evaluated.
-      # @param raw_value [Object] of the corresponding event
-      #   attribute value.
-      # @return [TrueClass, FalseClass]
-      def eval_attribute_value(event, raw_eval_string, raw_value)
-        eval_string = process_eval_string(event, raw_eval_string)
-        unless eval_string.nil?
-          begin
-            value = Marshal.load(Marshal.dump(raw_value))
-            !!Sandbox.eval(eval_string, value)
-          rescue StandardError, SyntaxError => error
-            @logger.error("filter attribute eval error", {
-              :event => event,
-              :raw_eval_string => raw_eval_string,
-              :raw_value => raw_value,
-              :error => error.to_s
-            })
-            false
-          end
-        else
-          false
-        end
-      end
-
-      # Determine if all filter attribute values match those of the
-      # corresponding event attributes. Attributes match if the value
-      # objects are equivalent, are both hashes with matching
-      # key/value pairs (recursive), have equal string values, or
-      # evaluate to true (Ruby eval).
-      #
-      # @param event [Hash]
-      # @param filter_attributes [Object]
-      # @param event_attributes [Object]
-      # @return [TrueClass, FalseClass]
-      def filter_attributes_match?(event, filter_attributes, event_attributes=nil)
-        event_attributes ||= event
-        filter_attributes.all? do |key, value_one|
-          value_two = event_attributes[key]
-          case
-          when value_one == value_two
-            true
-          when value_one.is_a?(Hash) && value_two.is_a?(Hash)
-            filter_attributes_match?(event, value_one, value_two)
-          when value_one.to_s == value_two.to_s
-            true
-          when value_one.is_a?(String) && value_one.start_with?(EVAL_PREFIX)
-            eval_attribute_value(event, value_one, value_two)
-          else
-            false
-          end
-        end
-      end
-
       # 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.
@@ -184,7 +90,7 @@ module Sensu
       def native_filter(filter_name, event)
         filter = @settings[:filters][filter_name]
         if in_filter_time_windows?(filter)
-          matched = filter_attributes_match?(event, filter[:attributes])
+          matched = attributes_match?(event, filter[:attributes])
           yield(filter[:negate] ? matched : !matched, filter_name)
         else
           yield(false, filter_name)