sensu 0.9.9.beta.2 → 0.9.9.beta.3

data/lib/sensu/constants.rb

@@ -1,16 +1,17 @@
 module Sensu
   unless defined?(Sensu::VERSION)
-    VERSION = '0.9.9.beta.2'
-  end
+    VERSION = '0.9.9.beta.3'
 
-  unless defined?(Sensu::DEFAULT_OPTIONS)
     DEFAULT_OPTIONS = {
       :config_file => '/etc/sensu/config.json',
-      :config_dir => '/etc/sensu/conf.d'
+      :config_dir => '/etc/sensu/conf.d',
+      :log_level => :info
     }
-  end
 
-  unless defined?(Sensu::SEVERITIES)
+    SETTINGS_CATEGORIES = [:checks, :filters, :mutators, :handlers]
+
+    EXTENSION_CATEGORIES = [:mutators, :handlers]
+
     SEVERITIES = %w[ok warning critical unknown]
   end
 end

data/lib/sensu/extensions.rb

@@ -0,0 +1,101 @@
+module Sensu
+  class Extensions
+    def initialize
+      @logger = Logger.get
+      @extensions = Hash.new
+      EXTENSION_CATEGORIES.each do |category|
+        @extensions[category] = Hash.new
+      end
+    end
+
+    def [](key)
+      @extensions[key]
+    end
+
+    EXTENSION_CATEGORIES.each do |category|
+      define_method(category.to_s.chop + '_exists?') do |extension_name|
+        @extensions[category].has_key?(extension_name)
+      end
+    end
+
+    def require_directory(directory)
+      Dir.glob(File.join(directory, '**/*.rb')).each do |file|
+        begin
+          require file
+        rescue ScriptError => error
+          @logger.error('failed to require extension', {
+            :extension_file => file,
+            :error => error
+          })
+          @logger.warn('ignoring extension', {
+            :extension_file => file
+          })
+        end
+      end
+    end
+
+    def load_all
+      require_directory(File.join(File.dirname(__FILE__), 'extensions'))
+      EXTENSION_CATEGORIES.each do |category|
+        extension_type = category.to_s.chop
+        Extension.const_get(extension_type.capitalize).descendants.each do |klass|
+          extension = klass.new
+          @extensions[category][extension.name] = extension
+          loaded(extension_type, extension.name, extension.description)
+        end
+      end
+    end
+
+    private
+
+    def loaded(type, name, description)
+      @logger.info('loaded extension', {
+        :type => type,
+        :name => name,
+        :description => description
+      })
+    end
+  end
+
+  module Extension
+    class Base
+      def name
+        'base'
+      end
+
+      def description
+        'extension description (change me)'
+      end
+
+      def definition
+        {
+          :type => 'extension',
+          :name => name
+        }
+      end
+
+      def [](key)
+        definition[key.to_sym]
+      end
+
+      def has_key?(key)
+        definition.has_key?(key.to_sym)
+      end
+
+      def run(event=nil, &block)
+        block.call('noop', 0)
+      end
+
+      def self.descendants
+        ObjectSpace.each_object(Class).select do |klass|
+          klass < self
+        end
+      end
+    end
+
+    EXTENSION_CATEGORIES.each do |category|
+      extension_type = category.to_s.chop
+      Object.const_set(extension_type.capitalize, Class.new(Base))
+    end
+  end
+end

data/lib/sensu/extensions/handlers/debug.rb

@@ -0,0 +1,17 @@
+module Sensu
+  module Extension
+    class Debug < Handler
+      def name
+        'debug'
+      end
+
+      def description
+        'outputs json event data'
+      end
+
+      def run(event, &block)
+        block.call(event.to_json, 0)
+      end
+    end
+  end
+end

data/lib/sensu/extensions/mutators/only_check_output.rb

@@ -0,0 +1,17 @@
+module Sensu
+  module Extension
+    class OnlyCheckOutput < Mutator
+      def name
+        'only_check_output'
+      end
+
+      def description
+        'returns check output'
+      end
+
+      def run(event, &block)
+        block.call(event[:check][:output], 0)
+      end
+    end
+  end
+end

data/lib/sensu/io.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 module Sensu
   class IO
     class << self

data/lib/sensu/{logger.rb → logstream.rb}

@@ -3,7 +3,9 @@ gem 'cabin', '0.4.4'
 require 'cabin'
 
 module Sensu
-  class Logger
+  class LogStream
+    attr_reader :logger
+
     def initialize
       @logger = Cabin::Channel.get
       STDOUT.sync = true
@@ -15,19 +17,16 @@ module Sensu
       @logger.level = log_level
     end
 
-    def reopen(file=nil)
-      file ||= @log_file
-      unless file.nil?
-        @log_file = file
-        if File.writable?(file) || !File.exist?(file) && File.writable?(File.dirname(file))
-          STDOUT.reopen(file, 'a')
-          STDOUT.sync = true
-          STDERR.reopen(STDOUT)
-        else
-          @logger.error('log file is not writable', {
-            :log_file => file
-          })
-        end
+    def reopen(file)
+      @log_file = file
+      if File.writable?(file) || !File.exist?(file) && File.writable?(File.dirname(file))
+        STDOUT.reopen(file, 'a')
+        STDOUT.sync = true
+        STDERR.reopen(STDOUT)
+      else
+        @logger.error('log file is not writable', {
+          :log_file => file
+        })
       end
     end
 
@@ -39,11 +38,15 @@ module Sensu
       end
       if Signal.list.include?('USR2')
         Signal.trap('USR2') do
-          reopen(@log_file)
+          if @log_file
+            reopen(@log_file)
+          end
         end
       end
     end
+  end
 
+  class Logger
     def self.get
       Cabin::Channel.get
     end
@@ -52,6 +55,7 @@ module Sensu
   class NullLogger
     [:debug, :info, :warn, :error, :fatal].each do |method|
       define_method(method) do |*arguments|
+        true
       end
     end
 

data/lib/sensu/process.rb

@@ -1,7 +1,7 @@
 module Sensu
   class Process
     def initialize
-      @logger = Sensu::Logger.get
+      @logger = Logger.get
     end
 
     def write_pid(file)

data/lib/sensu/rabbitmq.rb

@@ -0,0 +1,74 @@
+gem 'amqp', '0.9.8'
+
+require 'amqp'
+
+module Sensu
+  class RabbitMQError < StandardError; end
+
+  class RabbitMQ
+    attr_reader :channel
+
+    def initialize
+      @on_error = Proc.new {}
+      @before_reconnect = Proc.new {}
+      @after_reconnect = Proc.new {}
+    end
+
+    def on_error(&block)
+      @on_error = block
+    end
+
+    def before_reconnect(&block)
+      @before_reconnect = block
+    end
+
+    def after_reconnect(&block)
+      @after_reconnect = block
+    end
+
+    def connect(options={})
+      options.reject! do |key, value|
+        key == :heartbeat
+      end
+      on_failure = Proc.new do
+        error = RabbitMQError.new('cannot connect to rabbitmq')
+        @on_error.call(error)
+      end
+      @connection = AMQP.connect(options, {
+        :on_tcp_connection_failure => on_failure,
+        :on_possible_authentication_failure => on_failure
+      })
+      @connection.logger = NullLogger.get
+      @connection.on_tcp_connection_loss do |connection, settings|
+        unless connection.reconnecting?
+          @before_reconnect.call
+          connection.periodically_reconnect(5)
+        end
+      end
+      @channel = AMQP::Channel.new(@connection)
+      @channel.auto_recovery = true
+      @channel.on_error do |channel, channel_close|
+        error = RabbitMQError.new('rabbitmq channel closed')
+        @on_error.call(error)
+      end
+      @channel.on_recovery do
+        @after_reconnect.call
+      end
+    end
+
+    def connected?
+      @connection.connected?
+    end
+
+    def close
+      @connection.close
+    end
+
+    def self.connect(options={})
+      options ||= Hash.new
+      rabbitmq = self.new
+      rabbitmq.connect(options)
+      rabbitmq
+    end
+  end
+end

data/lib/sensu/redis.rb

@@ -1,122 +1,18 @@
-gem 'ruby-redis', '0.0.2'
+gem 'em-redis-unified', '0.4.1'
 
-require 'redis'
+require 'em-redis'
 
 module Sensu
-  class Redis < Redis::Client
-    attr_accessor :settings, :on_tcp_connection_failure
-
-    alias :em_reconnect :reconnect
-
-    def initialize(*arguments)
-      super
-      @logger = Sensu::Logger.get
-      @settings = Hash.new
-      @connection_established = false
-      @connected = false
-      @reconnecting = false
-      @closing_connection = false
-    end
-
-    def setup_heartbeat
-      @heartbeat ||= EM::PeriodicTimer.new(10) do
-        if connected?
-          ping
-        end
-      end
-    end
-
-    def connection_completed
-      @connection_established = true
-      @connected = true
-      @reconnecting = false
-      if @settings[:password]
-        auth(@settings[:password]).callback do |reply|
-          unless reply == 'OK'
-            @logger.fatal('redis authentication failed')
-            close_connection
-          end
-        end
-      end
-      info.callback do |reply|
-        redis_version = reply.split(/\n/).select { |v| v =~ /^redis_version/ }.first.split(/:/).last.chomp
-        if redis_version < '1.3.14'
-          @logger.fatal('redis version must be >= 2.0 RC 1')
-          close_connection
-        end
-      end
-      setup_heartbeat
-    end
-
-    def reconnect(immediate=false, wait=10)
-      if @reconnecting && !immediate
-        EM::Timer.new(wait) do
-          em_reconnect(@settings[:host], @settings[:port])
-        end
-      else
-        @reconnecting = true
-        em_reconnect(@settings[:host], @settings[:port])
-      end
-    end
-
-    def close
-      @closing_connection = true
-      close_connection
-    end
-
-    def on_tcp_connection_loss(&block)
-      if block.respond_to?(:call)
-        @on_tcp_connection_loss = block
-      end
-    end
-
-    def unbind
-      @connected = false
-      super
-      unless @closing_connection
-        if @connection_established
-          if @on_tcp_connection_loss
-            @on_tcp_connection_loss.call(self, @settings)
-          end
-        else
-          if @on_tcp_connection_failure
-            @on_tcp_connection_failure.call(self, @settings)
-          end
-        end
-      end
-    end
-
-    def connected?
-      @connected
-    end
-
-    def self.connect(options, additional={})
+  class Redis
+    def self.connect(options={})
       options ||= Hash.new
-      if options.is_a?(String)
-        begin
-          uri = URI.parse(options)
-          host = uri.host
-          port = uri.port || 6379
-          password = uri.password
-        rescue
-          @logger.fatal('invalid redis url')
-          @logger.fatal('SENSU NOT RUNNING!')
-          exit 2
+      connection = EM::Protocols::Redis.connect(options)
+      connection.info do |info|
+        if info[:redis_version] < '1.3.14'
+          klass = EM::Protocols::Redis::RedisError
+          message = 'redis version must be >= 2.0 RC 1'
+          connection.error(klass, message)
         end
-      else
-        host = options[:host] || 'localhost'
-        port = options[:port] || 6379
-        password = options[:password]
-      end
-      connection = EM::connect(host, port, self) do |redis|
-        redis.settings = {
-          :host => host,
-          :port => port,
-          :password => password
-        }
-      end
-      if additional[:on_tcp_connection_failure].respond_to?(:call)
-        connection.on_tcp_connection_failure = additional[:on_tcp_connection_failure]
       end
       connection
     end