sensu 0.17.0.beta → 0.17.0.beta.1

data/lib/sensu/server/filter.rb

@@ -0,0 +1,309 @@
+require "sensu/server/sandbox"
+
+module Sensu
+  module Server
+    module Filter
+      # 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.
+      #
+      # @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.
+      # @return [TrueClass, FalseClass]
+      def check_request_subdued?(check)
+        if check[:subdue] && check[:subdue][:at] == "publisher"
+          action_subdued?(check[:subdue])
+        else
+          false
+        end
+      end
+
+      # Determine if handling is disabled for an event. Check
+      # definitions can disable event handling with an attribute,
+      # `:handle`, by setting it to `false`.
+      #
+      # @param event [Hash]
+      # @return [TrueClass, FalseClass]
+      def handling_disabled?(event)
+        event[:check][:handle] == false
+      end
+
+      # Determine if an event with an action should be handled. An
+      # event action of `:flapping` indicates that the event state is
+      # flapping, and the event should not be handled unless its
+      # handler has `:handle_flapping` set to `true`.
+      #
+      # @param handler [Hash] definition.
+      # @param event [Hash]
+      # @return [TrueClass, FalseClass]
+      def handle_action?(handler, event)
+        event[:action] != :flapping ||
+          (event[:action] == :flapping && !!handler[:handle_flapping])
+      end
+
+      # Determine if an event with a check severity will be handled.
+      # Event handlers can specify the check severities they will
+      # handle, using the definition attribute `:severities`. The
+      # possible severities are "ok", "warning", "critical", and
+      # "unknown". Handler severity filtering is bypassed when the
+      # event `:action` is `:resolve`, if the check history contains
+      # one of the specified severities since the last OK result.
+      #
+      # @param handler [Hash] definition.
+      # @param event [Hash]
+      # @return [TrueClass, FalseClass]
+      def handle_severity?(handler, event)
+        if handler.has_key?(:severities)
+          case event[:action]
+          when :resolve
+            event[:check][:history].reverse[1..-1].any? do |status|
+              if status.to_i == 0
+                break false
+              end
+              severity = SEVERITIES[status.to_i] || "unknown"
+              handler[:severities].include?(severity)
+            end
+          else
+            severity = SEVERITIES[event[:check][:status]] || "unknown"
+            handler[:severities].include?(severity)
+          end
+        else
+          true
+        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. The expression is expected to return a
+      # boolean value.
+      #
+      # @param raw_eval_string [String] containing the Ruby
+      #   expression to be evaluated.
+      # @param value [Object] of the corresponding event attribute.
+      # @return [TrueClass, FalseClass]
+      def eval_attribute_value(raw_eval_string, value)
+        begin
+          eval_string = raw_eval_string.gsub(/^eval:(\s+)?/, "")
+          !!Sandbox.eval(eval_string, value)
+        rescue => error
+          @logger.error("filter attribute eval error", {
+            :raw_eval_string => raw_eval_string,
+            :value => value,
+            :error => error.to_s
+          })
+          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 hash_one [Hash]
+      # @param hash_two [Hash]
+      # @return [TrueClass, FalseClass]
+      def filter_attributes_match?(hash_one, hash_two)
+        hash_one.all? do |key, value_one|
+          value_two = hash_two[key]
+          case
+          when value_one == value_two
+            true
+          when value_one.is_a?(Hash) && value_two.is_a?(Hash)
+            filter_attributes_match?(value_one, value_two)
+          when hash_one[key].to_s == hash_two[key].to_s
+            true
+          when value_one.is_a?(String) && value_one.start_with?("eval:")
+            eval_attribute_value(value_one, value_two)
+          else
+            false
+          end
+        end
+      end
+
+      # Determine if an event is filtered by an event filter, standard
+      # 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.
+      #
+      # @param filter_name [String]
+      # @param event [Hash]
+      # @param callback [Proc]
+      def event_filter(filter_name, event, &callback)
+        case
+        when @settings.filter_exists?(filter_name)
+          filter = @settings[:filters][filter_name]
+          matched = filter_attributes_match?(filter[:attributes], event)
+          callback.call(filter[:negate] ? matched : !matched)
+        when @extensions.filter_exists?(filter_name)
+          extension = @extensions[:filters][filter_name]
+          extension.safe_run(event) do |output, status|
+            callback.call(status == 0)
+          end
+        else
+          @logger.error("unknown filter", :filter_name => filter_name)
+          callback.call(false)
+        end
+      end
+
+      # Determine if an event is filtered for a handler. If a handler
+      # specifies one or more filters, via `:filters` or `:filter`,
+      # the `event_filter()` method is called for each of them. If any
+      # of the filters return `true`, the event is filtered for the
+      # handler. If no filters are defined in the handler definition,
+      # the event is not filtered.
+      #
+      # @param handler [Hash] definition.
+      # @param event [Hash]
+      # @param callback [Proc]
+      def event_filtered?(handler, event, &callback)
+        if handler.has_key?(:filters) || handler.has_key?(:filter)
+          filter_list = Array(handler[:filters] || handler[:filter])
+          filter_results = EM::Iterator.new(filter_list)
+          run_filters = Proc.new do |filter_name, iterator|
+            event_filter(filter_name, event) do |filtered|
+              iterator.return(filtered)
+            end
+          end
+          filtered = Proc.new do |results|
+            callback.call(results.any?)
+          end
+          filter_results.map(run_filters, filtered)
+        else
+          callback.call(false)
+        end
+      end
+
+      # Attempt to filter an event for a handler. This method will
+      # check to see if handling is disabled, if the event action is
+      # handled, if the event check severity is handled, if the
+      # handler is sbuded, and if the event is filtered by any of the
+      # filters specified in the handler definition.
+      #
+      # @param handler [Hash] definition.
+      # @param event [Hash]
+      # @param callback [Proc]
+      def filter_event(handler, event, &callback)
+        details = {:handler => handler, :event => event}
+        if handling_disabled?(event)
+          @logger.info("event handling disabled for event", details)
+        elsif !handle_action?(handler, event)
+          @logger.info("handler does not handle action", details)
+        elsif !handle_severity?(handler, event)
+          @logger.info("handler does not handle event severity", details)
+        elsif handler_subdued?(handler, event)
+          @logger.info("handler is subdued", details)
+        else
+          event_filtered?(handler, event) do |filtered|
+            unless filtered
+              callback.call(event)
+            else
+              @logger.info("event was filtered", details)
+              @handling_event_count -= 1 if @handling_event_count
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/server/handle.rb

@@ -0,0 +1,168 @@
+require "sensu/server/socket"
+
+module Sensu
+  module Server
+    module Handle
+      # Create a handler error callback, for logging the error and
+      # decrementing the `@handling_event_count` by `1`.
+      #
+      # @param handler [Object]
+      # @param event_data [Object]
+      # @return [Proc] error callback.
+      def handler_error(handler, event_data)
+        Proc.new do |error|
+          @logger.error("handler error", {
+            :handler => handler,
+            :event_data => event_data,
+            :error => error.to_s
+          })
+          @handling_event_count -= 1 if @handling_event_count
+        end
+      end
+
+      # Execute a pipe event handler, using the defined handler
+      # command to spawn a process, passing it event data via STDIN.
+      # Log the handler output lines and decrement the
+      # `@handling_event_count` by `1` when the handler executes
+      # successfully.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] provided to the spawned handler
+      #   process via STDIN.
+      def pipe_handler(handler, event_data)
+        options = {:data => event_data, :timeout => handler[:timeout]}
+        Spawn.process(handler[:command], options) do |output, status|
+          @logger.info("handler output", {
+            :handler => handler,
+            :output => output.lines
+          })
+          @handling_event_count -= 1 if @handling_event_count
+        end
+      end
+
+      # Connect to a TCP socket and transmit event data to it, then
+      # close the connection. The `Sensu::Server::Socket` connection
+      # handler is used for the socket. The socket timeouts are
+      # configurable via the handler definition, `:timeout`. The
+      # `handler_error()` method is used to create the `on_error`
+      # callback for the connection handler. The `on_error` callback
+      # is call in the event of any error(s). The
+      # `@handling_event_count` is decremented by `1` when the data is
+      # transmitted successfully, `on_success`.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to transmit to the TCP socket.
+      def tcp_handler(handler, event_data)
+        on_error = handler_error(handler, event_data)
+        begin
+          EM::connect(handler[:socket][:host], handler[:socket][:port], Socket) do |socket|
+            socket.on_success = Proc.new do
+              @handling_event_count -= 1 if @handling_event_count
+            end
+            socket.on_error = on_error
+            timeout = handler[:timeout] || 10
+            socket.pending_connect_timeout = timeout
+            socket.comm_inactivity_timeout = timeout
+            socket.send_data(event_data.to_s)
+            socket.close_connection_after_writing
+          end
+        rescue => error
+          on_error.call(error)
+        end
+      end
+
+      # Transmit event data to a UDP socket, then close the
+      # connection. The `@handling_event_count` is decremented by `1`
+      # when the data is assumed to have been transmitted.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to transmit to the UDP socket.
+      def udp_handler(handler, event_data)
+        begin
+          EM::open_datagram_socket("0.0.0.0", 0, nil) do |socket|
+            socket.send_datagram(event_data.to_s, handler[:socket][:host], handler[:socket][:port])
+            socket.close_connection_after_writing
+            @handling_event_count -= 1 if @handling_event_count
+          end
+        rescue => error
+          handler_error(handler, event_data).call(error)
+        end
+      end
+
+      # Publish event data to a Sensu transport pipe. Event data that
+      # is `nil` or empty will not be published, to prevent transport
+      # errors. The `@handling_event_count` is decremented by `1`,
+      # even if the event data is not published.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to publish to the transport pipe.
+      def transport_handler(handler, event_data)
+        unless event_data.nil? || event_data.empty?
+          pipe = handler[:pipe]
+          pipe_options = pipe[:options] || {}
+          @transport.publish(pipe[:type].to_sym, pipe[:name], event_data, pipe_options) do |info|
+            if info[:error]
+              handler_error(handler, event_data).call(info[:error])
+            end
+          end
+        end
+        @handling_event_count -= 1 if @handling_event_count
+      end
+
+      # Run a handler extension, within the Sensu EventMachine reactor
+      # (event loop). The extension API `safe_run()` method is used to
+      # guard against most errors. The `safe_run()` callback is always
+      # called, logging the extension run output and status, and
+      # decrementing the `@handling_event_count` by `1`.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to pass to the handler extension.
+      def handler_extension(handler, event_data)
+        handler.safe_run(event_data) do |output, status|
+          @logger.info("handler extension output", {
+            :extension => handler.definition,
+            :output => output,
+            :status => status
+          })
+          @handling_event_count -= 1 if @handling_event_count
+        end
+      end
+
+      # Route the event data to the appropriate handler type method.
+      # Routing is done using the handler definition, `:type`.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to pass to the handler type method.
+      def handler_type_router(handler, event_data)
+        case handler[:type]
+        when "pipe"
+          pipe_handler(handler, event_data)
+        when "tcp"
+          tcp_handler(handler, event_data)
+        when "udp"
+          udp_handler(handler, event_data)
+        when "transport"
+          transport_handler(handler, event_data)
+        when "extension"
+          handler_extension(handler, event_data)
+        end
+      end
+
+      # Handle an event, providing event data to an event handler.
+      # This method logs event data and the handler definition at the
+      # debug log level, then calls the `handler_type_router()`
+      # method.
+      #
+      # @param handler [Hash] definition.
+      # @param event_data [Object] to pass to an event handler.
+      def handle_event(handler, event_data)
+        definition = handler.is_a?(Hash) ? handler : handler.definition
+        @logger.debug("handling event", {
+          :event_data => event_data,
+          :handler => definition
+        })
+        handler_type_router(handler, event_data)
+      end
+    end
+  end
+end

data/lib/sensu/server/mutate.rb

@@ -0,0 +1,92 @@
+module Sensu
+  module Server
+    module Mutate
+      # Create a mutator callback (Proc). A mutator callback takes two
+      # parameters, for the mutator output and status code. The
+      # created callback can be used for standard mutators and mutator
+      # extensions. The provided callback will only be called when the
+      # mutator status is `0` (OK). If the status is not `0`, an error
+      # is logged, and the `@handling_event_count` is decremented by
+      # `1`.
+      #
+      # @param mutator [Object] definition or extension.
+      # @param event [Hash] data.
+      # @param callback [Proc] to call when the mutator status is `0`.
+      # @return [Proc] mutator callback.
+      def mutator_callback(mutator, event, &callback)
+        Proc.new do |output, status|
+          if status == 0
+            callback.call(output)
+          else
+            definition = mutator.is_a?(Hash) ? mutator : mutator.definition
+            @logger.error("mutator error", {
+              :mutator => definition,
+              :event => event,
+              :output => output,
+              :status => status
+            })
+            @handling_event_count -= 1 if @handling_event_count
+          end
+        end
+      end
+
+      # Execute a standard mutator (pipe), spawn a process using the
+      # mutator command and pipe the event data to it via STDIN. The
+      # `mutator_callback()` method is used to create the mutator
+      # callback, wrapping the provided callback (event handler).
+      #
+      # @param mutator [Hash] definition.
+      # @param event [Hash] data.
+      # @param callback [Proc] to call when the mutator executes
+      #   successfully.
+      def pipe_mutator(mutator, event, &callback)
+        options = {:data => MultiJson.dump(event), :timeout => mutator[:timeout]}
+        block = mutator_callback(mutator, event, &callback)
+        Spawn.process(mutator[:command], options, &block)
+      end
+
+      # Run a mutator extension, within the Sensu EventMachine reactor
+      # (event loop). The `mutator_callback()` method is used to
+      # create the mutator callback, wrapping the provided callback
+      # (event handler).
+      #
+      # @param mutator [Object] extension.
+      # @param event [Hash] data.
+      # @param callback [Proc] to call when the mutator runs
+      #   successfully.
+      def mutator_extension(mutator, event, &callback)
+        block = mutator_callback(mutator, event, &callback)
+        mutator.safe_run(event, &block)
+      end
+
+      # Mutate event data for a handler. By default, the "json"
+      # mutator is used, unless the handler specifies another mutator.
+      # If a mutator does not exist, not defined or a missing
+      # extension, an error will be logged and the
+      # `@handling_event_count` is decremented by `1`. This method
+      # first checks for the existence of a standard mutator, then
+      # checks for an extension if a standard mutator is not defined.
+      #
+      # @param handler [Hash] definition.
+      # @param event [Hash] data.
+      # @param callback [Proc] to call when the mutator executes/runs
+      #   successfully (event handler).
+      def mutate_event(handler, event, &callback)
+        mutator_name = handler[:mutator] || "json"
+        case
+        when @settings.mutator_exists?(mutator_name)
+          mutator = @settings[:mutators][mutator_name]
+          pipe_mutator(mutator, event, &callback)
+        when @extensions.mutator_exists?(mutator_name)
+          mutator = @extensions[:mutators][mutator_name]
+          mutator_extension(mutator, event, &callback)
+        else
+          @logger.error("unknown mutator", {
+            :mutator_name => mutator_name
+          })
+          @handling_event_count -= 1 if @handling_event_count
+        end
+      end
+    end
+  end
+end