sensu 0.9.5 → 0.9.6.beta

data/lib/sensu/base.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+
+gem 'eventmachine', '~> 1.0.0.beta.4'
+
+require 'optparse'
+require 'json'
+require 'cabin'
+require 'amqp'
+
+require File.join(File.dirname(__FILE__), 'patches', 'ruby')
+require File.join(File.dirname(__FILE__), 'patches', 'amqp')
+
+require File.join(File.dirname(__FILE__), 'constants')
+require File.join(File.dirname(__FILE__), 'cli')
+require File.join(File.dirname(__FILE__), 'logger')
+require File.join(File.dirname(__FILE__), 'settings')
+require File.join(File.dirname(__FILE__), 'process')
+
+module Sensu
+  class Base
+    attr_reader :options, :logger, :settings
+
+    def initialize(options={})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @logger = Cabin::Channel.get
+      setup_logging
+      setup_settings
+      setup_process
+    end
+
+    def setup_logging
+      Sensu::Logger.new(@options)
+    end
+
+    def setup_settings
+      @settings = Sensu::Settings.new
+      @settings.load_env
+      @settings.load_file(@options[:config_file])
+      Dir[@options[:config_dir] + '/**/*.json'].each do |file|
+        @settings.load_file(file)
+      end
+      begin
+        @settings.validate
+      rescue => error
+        @logger.fatal('CONFIG INVALID', {
+          :error => error.to_s
+        })
+        @logger.fatal('SENSU NOT RUNNING!')
+        exit 2
+      end
+    end
+
+    def setup_process
+      Sensu::Process.new(@options)
+    end
+  end
+end

data/lib/sensu/cli.rb

@@ -0,0 +1,37 @@
+module Sensu
+  class CLI
+    def self.read(arguments=ARGV)
+      options = Hash.new
+      optparse = OptionParser.new do |opts|
+        opts.on('-h', '--help', 'Display this message') do
+          puts opts
+          exit
+        end
+        opts.on('-V', '--version', 'Display version') do
+          puts VERSION
+          exit
+        end
+        opts.on('-c', '--config FILE', 'Sensu JSON config FILE. Default is /etc/sensu/config.json') do |file|
+          options[:config_file] = file
+        end
+        opts.on('-d', '--config_dir DIR', 'DIR for supplemental Sensu JSON config files. Default is /etc/sensu/conf.d/') do |dir|
+          options[:config_dir] = dir
+        end
+        opts.on('-l', '--log FILE', 'Log to a given FILE. Default is to log to stdout') do |file|
+          options[:log_file] = file
+        end
+        opts.on('-v', '--verbose', 'Enable verbose logging') do
+          options[:verbose] = true
+        end
+        opts.on('-b', '--background', 'Fork into the background') do
+          options[:daemonize] = true
+        end
+        opts.on('-p', '--pid_file FILE', 'Write the PID to a given FILE') do |file|
+          options[:pid_file] = file
+        end
+      end
+      optparse.parse!(arguments)
+      DEFAULT_OPTIONS.merge(options)
+    end
+  end
+end

data/lib/sensu/client.rb

@@ -1,23 +1,17 @@
-require File.join(File.dirname(__FILE__), 'config')
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'socket')
 
 module Sensu
   class Client
     def self.run(options={})
       client = self.new(options)
-      if options[:daemonize]
-        Process.daemonize
-      end
-      if options[:pid_file]
-        Process.write_pid(options[:pid_file])
-      end
-      EM::threadpool_size = 14
       EM::run do
         client.setup_rabbitmq
         client.setup_keepalives
         client.setup_subscriptions
         client.setup_rabbitmq_monitor
         client.setup_standalone
-        client.setup_socket
+        client.setup_sockets
 
         %w[INT TERM].each do |signal|
           Signal.trap(signal) do
@@ -28,27 +22,31 @@ module Sensu
     end
 
     def initialize(options={})
-      config = Sensu::Config.new(options)
-      @logger = config.logger
-      @settings = config.settings
+      base = Sensu::Base.new(options)
+      @logger = base.logger
+      @settings = base.settings
       @timers = Array.new
       @checks_in_progress = Array.new
     end
 
     def setup_rabbitmq
-      @logger.debug('[rabbitmq] -- connecting to rabbitmq')
-      @rabbitmq = AMQP.connect(@settings.rabbitmq.to_hash.symbolize_keys)
+      @logger.debug('connecting to rabbitmq', {
+        :settings => @settings[:rabbitmq]
+      })
+      @rabbitmq = AMQP.connect(@settings[:rabbitmq])
       @amq = AMQP::Channel.new(@rabbitmq)
     end
 
     def publish_keepalive
-      @settings.client.timestamp = Time.now.to_i
-      @logger.debug('[keepalive] -- publishing keepalive -- ' + @settings.client.timestamp.to_s)
-      @amq.queue('keepalives').publish(@settings.client.to_json)
+      payload = @settings[:client].merge(:timestamp => Time.now.to_i)
+      @logger.debug('publishing keepalive', {
+        :payload => payload
+      })
+      @amq.queue('keepalives').publish(payload.to_json)
     end
 
     def setup_keepalives
-      @logger.debug('[keepalive] -- setup keepalives')
+      @logger.debug('scheduling keepalives')
       publish_keepalive
       @timers << EM::PeriodicTimer.new(30) do
         unless @rabbitmq.reconnecting?
@@ -58,111 +56,133 @@ module Sensu
     end
 
     def publish_result(check)
-      @logger.info('[result] -- publishing check result -- ' + [check.name, check.status, check.output.gsub(/\n/, '\n')].join(' -- '))
-      @amq.queue('results').publish({
-        :client => @settings.client.name,
-        :check => check.to_hash
-      }.to_json)
+      payload = {
+        :client => @settings[:client][:name],
+        :check => check
+      }
+      @logger.info('publishing check result', {
+        :payload => payload
+      })
+      @amq.queue('results').publish(payload.to_json)
     end
 
     def execute_check(check)
-      @logger.debug('[execute] -- attempting to execute check -- ' + check.name)
-      if @settings.checks.key?(check.name)
-        unless @checks_in_progress.include?(check.name)
-          @logger.debug('[execute] -- executing check -- ' + check.name)
-          @checks_in_progress.push(check.name)
+      @logger.debug('attempting to execute check', {
+        :check => check
+      })
+      if @settings.check_exists?(check[:name])
+        unless @checks_in_progress.include?(check[:name])
+          @logger.debug('executing check', {
+            :check => check
+          })
+          @checks_in_progress.push(check[:name])
           unmatched_tokens = Array.new
-          command = @settings.checks[check.name].command.gsub(/:::(.*?):::/) do
+          command = @settings[:checks][check[:name]][:command].gsub(/:::(.*?):::/) do
             token = $1.to_s
             begin
-              value = @settings.client.instance_eval(token)
-              if value.nil?
-                unmatched_tokens.push(token)
-              end
-            rescue NoMethodError
-              value = nil
+              substitute = @settings[:client].instance_eval(token)
+            rescue NameError, NoMethodError
+              substitute = nil
+            end
+            if substitute.nil?
               unmatched_tokens.push(token)
             end
-            value
+            substitute
           end
           if unmatched_tokens.empty?
             execute = proc do
-              Bundler.with_clean_env do
-                started = Time.now.to_f
-                begin
-                  IO.popen(command + ' 2>&1') do |io|
-                    check.output = io.read
-                  end
-                  check.status = $?.exitstatus
-                rescue => error
-                  @logger.warn('[execute] -- unexpected error: ' + error.to_s)
-                  check.output = 'Unexpected error: ' + error.to_s
-                  check.status = 2
+              started = Time.now.to_f
+              begin
+                IO.popen(command + ' 2>&1') do |io|
+                  check[:output] = io.read
                 end
-                check.duration = ('%.3f' % (Time.now.to_f - started)).to_f
+                check[:status] = $?.exitstatus
+              rescue => error
+                @logger.warn('unexpected error', {
+                  :error => error.to_s
+                })
+                check[:output] = 'Unexpected error: ' + error.to_s
+                check[:status] = 2
               end
+              check[:duration] = ('%.3f' % (Time.now.to_f - started)).to_f
             end
             publish = proc do
-              unless check.status.nil?
+              unless check[:status].nil?
                 publish_result(check)
               else
-                @logger.warn('[execute] -- nil exit status code -- ' + check.name)
+                @logger.warn('nil exit status code', {
+                  :check => check
+                })
               end
-              @checks_in_progress.delete(check.name)
+              @checks_in_progress.delete(check[:name])
             end
             EM::defer(execute, publish)
           else
-            @logger.warn('[execute] -- missing client attributes -- ' + unmatched_tokens.join(', ') + ' -- ' + check.name)
-            check.output = 'Missing client attributes: ' + unmatched_tokens.join(', ')
-            check.status = 3
-            check.handle = false
+            @logger.warn('missing client attributes', {
+              :check => check,
+              :unmatched_tokens => unmatched_tokens
+            })
+            check[:output] = 'Missing client attributes: ' + unmatched_tokens.join(', ')
+            check[:status] = 3
+            check[:handle] = false
             publish_result(check)
-            @checks_in_progress.delete(check.name)
+            @checks_in_progress.delete(check[:name])
           end
         else
-          @logger.warn('[execute] -- previous check execution still in progress -- ' + check.name)
+          @logger.warn('previous check execution in progress', {
+            :check => check
+          })
         end
       else
-        @logger.warn('[execute] -- unkown check -- ' + check.name)
-        check.output = 'Unknown check'
-        check.status = 3
-        check.handle = false
+        @logger.warn('unknown check', {
+          :check => check
+        })
+        check[:output] = 'Unknown check'
+        check[:status] = 3
+        check[:handle] = false
         publish_result(check)
-        @checks_in_progress.delete(check.name)
+        @checks_in_progress.delete(check[:name])
       end
     end
 
     def setup_subscriptions
-      @logger.debug('[subscribe] -- setup subscriptions')
-      @uniq_queue_name ||= rand(36**32).to_s(36)
+      @logger.debug('subscribing to client subscriptions')
+      @uniq_queue_name ||= rand(36 ** 32).to_s(36)
       @check_request_queue = @amq.queue(@uniq_queue_name, :auto_delete => true)
-      @settings.client.subscriptions.uniq.each do |exchange|
-        @logger.debug('[subscribe] -- queue binding to exchange -- ' + exchange)
-        @check_request_queue.bind(@amq.fanout(exchange))
+      @settings[:client][:subscriptions].uniq.each do |exchange_name|
+        @logger.debug('binding queue to exchange', {
+          :queue => @uniq_queue_name,
+          :exchange => {
+            :name => exchange_name,
+            :type => 'fanout'
+          }
+        })
+        @check_request_queue.bind(@amq.fanout(exchange_name))
       end
-      @check_request_queue.subscribe do |check_request_json|
+      @check_request_queue.subscribe do |payload|
         begin
-          check = Hashie::Mash.new(JSON.parse(check_request_json))
-          if check.name.is_a?(String) && check.issued.is_a?(Integer)
-            @logger.info('[subscribe] -- received check request -- ' + check.name)
-            execute_check(check)
-          else
-            @logger.warn('[subscribe] -- invalid check request: ' + check_request_json)
-          end
+          check = JSON.parse(payload, :symbolize_names => true)
+          @logger.info('received check request', {
+            :check => check
+          })
+          execute_check(check)
         rescue JSON::ParserError => error
-          @logger.warn('[subscribe] -- check request must be valid json: ' + error.to_s)
+          @logger.warn('check request payload must be valid json', {
+            :payload => payload,
+            :error => error.to_s
+          })
         end
       end
     end
 
     def setup_rabbitmq_monitor
-      @logger.debug('[monitor] -- setup rabbitmq monitor')
+      @logger.debug('monitoring rabbitmq connection')
       @timers << EM::PeriodicTimer.new(5) do
         if @rabbitmq.reconnecting?
-          @logger.warn('[monitor] -- reconnecting to rabbitmq')
+          @logger.warn('reconnecting to rabbitmq')
         else
           unless @check_request_queue.subscribed?
-            @logger.warn('[monitor] -- re-subscribing to client subscriptions')
+            @logger.warn('re-subscribing to client subscriptions')
             setup_subscriptions
           end
         end
@@ -170,18 +190,17 @@ module Sensu
     end
 
     def setup_standalone(options={})
-      @logger.debug('[standalone] -- setup standalone checks')
+      @logger.debug('scheduling standalone checks')
       standalone_check_count = 0
-      @settings.checks.each do |name, details|
-        if details.standalone
+      stagger = options[:test] ? 0 : 7
+      @settings.checks.each do |check|
+        if check[:standalone]
           standalone_check_count += 1
-          check = Hashie::Mash.new(details.merge(:name => name))
-          stagger = options[:test] ? 0 : 7
-          @timers << EM::Timer.new(stagger*standalone_check_count) do
-            interval = options[:test] ? 0.5 : details.interval
+          @timers << EM::Timer.new(stagger * standalone_check_count) do
+            interval = options[:test] ? 0.5 : check[:interval]
             @timers << EM::PeriodicTimer.new(interval) do
               unless @rabbitmq.reconnecting?
-                check.issued = Time.now.to_i
+                check[:issued] = Time.now.to_i
                 execute_check(check)
               end
             end
@@ -190,24 +209,34 @@ module Sensu
       end
     end
 
-    def setup_socket
-      @logger.debug('[socket] -- starting up client tcp socket')
-      EM::start_server('127.0.0.1', 3030, ClientSocket) do |socket|
+    def setup_sockets
+      @logger.debug('binding client tcp socket')
+      EM::start_server('127.0.0.1', 3030, Sensu::Socket) do |socket|
+        socket.protocol = :tcp
+        socket.logger = @logger
         socket.settings = @settings
+        socket.amq = @amq
+      end
+      @logger.debug('binding client udp socket')
+      EM::open_datagram_socket('127.0.0.1', 3030, Sensu::Socket) do |socket|
+        socket.protocol = :udp
         socket.logger = @logger
+        socket.settings = @settings
         socket.amq = @amq
       end
     end
 
     def stop_reactor
-      @logger.info('[stop] -- completing checks in progress')
+      @logger.info('completing checks in progress', {
+        :checks_in_progress => @checks_in_progress
+      })
       complete_in_progress = EM::tick_loop do
         if @checks_in_progress.empty?
           :stop
         end
       end
       complete_in_progress.on_stop do
-        @logger.warn('[stop] -- stopping reactor')
+        @logger.warn('stopping reactor')
         EM::PeriodicTimer.new(0.25) do
           EM::stop_event_loop
         end
@@ -215,12 +244,15 @@ module Sensu
     end
 
     def stop(signal)
-      @logger.warn('[stop] -- stopping sensu client -- ' + signal)
+      @logger.warn('received signal', {
+        :signal => signal
+      })
+      @logger.warn('stopping')
       @timers.each do |timer|
         timer.cancel
       end
       unless @rabbitmq.reconnecting?
-        @logger.warn('[stop] -- unsubscribing from client subscriptions')
+        @logger.warn('unsubscribing from client subscriptions')
         @check_request_queue.unsubscribe do
           stop_reactor
         end
@@ -229,39 +261,4 @@ module Sensu
       end
     end
   end
-
-  class ClientSocket < EM::Connection
-    attr_accessor :settings, :logger, :amq
-
-    def receive_data(data)
-      if data == 'ping'
-        @logger.debug('[socket] -- received ping')
-        send_data('pong')
-      else
-        @logger.debug('[socket] -- received data -- ' + data)
-        begin
-          check = Hashie::Mash.new(JSON.parse(data))
-          validates = %w[name output].all? do |key|
-            check[key].is_a?(String)
-          end
-          check.issued = Time.now.to_i
-          check.status ||= 0
-          if validates && check.status.is_a?(Integer)
-            @logger.info('[socket] -- publishing check result -- ' + [check.name, check.status, check.output.gsub(/\n/, '\n')].join(' -- '))
-            @amq.queue('results').publish({
-              :client => @settings.client.name,
-              :check => check.to_hash
-            }.to_json)
-            send_data('ok')
-          else
-            @logger.warn('[socket] -- check name and output must be strings, status defaults to 0 -- e.g. {"name": "x", "output": "y"}')
-            send_data('invalid')
-          end
-        rescue JSON::ParserError => error
-          @logger.warn('[socket] -- check result must be valid json: ' + error.to_s)
-          send_data('invalid')
-        end
-      end
-    end
-  end
 end