sensu 0.9.11 → 0.9.12.beta

data/lib/sensu/constants.rb

@@ -1,17 +1,15 @@
 module Sensu
   unless defined?(Sensu::VERSION)
-    VERSION = '0.9.11'
+    VERSION = '0.9.12.beta'
 
-    DEFAULT_OPTIONS = {
-      :config_file => '/etc/sensu/config.json',
-      :config_dir => '/etc/sensu/conf.d',
-      :log_level => :info
-    }
+    LOG_LEVELS = [:debug, :info, :warn, :error, :fatal]
 
     SETTINGS_CATEGORIES = [:checks, :filters, :mutators, :handlers]
 
-    EXTENSION_CATEGORIES = [:mutators, :handlers]
+    EXTENSION_CATEGORIES = [:checks, :mutators, :handlers]
 
     SEVERITIES = %w[ok warning critical unknown]
+
+    STOP_SIGNALS = %w[INT TERM]
   end
 end

data/lib/sensu/extensions.rb

@@ -13,8 +13,14 @@ module Sensu
     end
 
     EXTENSION_CATEGORIES.each do |category|
-      define_method(category.to_s.chop + '_exists?') do |extension_name|
-        @extensions[category].has_key?(extension_name)
+      define_method(category) do
+        @extensions[category].map do |name, extension|
+          extension.definition
+        end
+      end
+
+      define_method(category.to_s.chop + '_exists?') do |name|
+        @extensions[category].has_key?(name)
       end
     end
 
@@ -22,7 +28,7 @@ module Sensu
       path = directory.gsub(/\\(?=\S)/, '/')
       Dir.glob(File.join(path, '**/*.rb')).each do |file|
         begin
-          require file
+          require File.expand_path(file)
         rescue ScriptError => error
           @logger.error('failed to require extension', {
             :extension_file => file,

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

@@ -10,7 +10,7 @@ module Sensu
       end
 
       def run(event, settings, &block)
-        block.call(event.to_json, 0)
+        block.call(Oj.dump(event), 0)
       end
     end
   end

data/lib/sensu/logstream.rb

@@ -1,20 +1,36 @@
-gem 'cabin', '0.4.4'
-
-require 'cabin'
-
 module Sensu
   class LogStream
-    attr_reader :logger
-
     def initialize
-      @logger = Cabin::Channel.get
+      @log_stream = EM::Queue.new
+      @log_level = :info
       STDOUT.sync = true
       STDERR.reopen(STDOUT)
-      @logger.subscribe(STDOUT)
+      setup_writer
     end
 
-    def level=(log_level)
-      @logger.level = log_level
+    def level=(level)
+      @log_level = level
+    end
+
+    def level_filtered?(level)
+      LOG_LEVELS.index(level) < LOG_LEVELS.index(@log_level)
+    end
+
+    def add(level, *arguments)
+      unless level_filtered?(level)
+        log_event = create_log_event(level, *arguments)
+        if EM::reactor_running?
+          @log_stream << log_event
+        else
+          puts log_event
+        end
+      end
+    end
+
+    LOG_LEVELS.each do |level|
+      define_method(level) do |*arguments|
+        add(level, *arguments)
+      end
     end
 
     def reopen(file)
@@ -24,7 +40,7 @@ module Sensu
         STDOUT.sync = true
         STDERR.reopen(STDOUT)
       else
-        @logger.error('log file is not writable', {
+        error('log file is not writable', {
           :log_file => file
         })
       end
@@ -33,7 +49,7 @@ module Sensu
     def setup_traps
       if Signal.list.include?('USR1')
         Signal.trap('USR1') do
-          @logger.level = @logger.level == :info ? :debug : :info
+          @log_level = @log_level == :info ? :debug : :info
         end
       end
       if Signal.list.include?('USR2')
@@ -44,23 +60,34 @@ module Sensu
         end
       end
     end
-  end
 
-  class Logger
-    def self.get
-      Cabin::Channel.get
+    private
+
+    def create_log_event(level, message, data=nil)
+      log_event = Hash.new
+      log_event[:timestamp] = Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6N%z")
+      log_event[:level] = level
+      log_event[:message] = message
+      if data.is_a?(Hash)
+        log_event.merge!(data)
+      end
+      Oj.dump(log_event)
     end
-  end
 
-  class NullLogger
-    [:debug, :info, :warn, :error, :fatal].each do |method|
-      define_method(method) do |*arguments|
-        true
+    def setup_writer
+      writer = Proc.new do |log_event|
+        puts log_event
+        EM::next_tick do
+          @log_stream.pop(&writer)
+        end
       end
+      @log_stream.pop(&writer)
     end
+  end
 
+  class Logger
     def self.get
-      self.new
+      @logger ||= LogStream.new
     end
   end
 end

data/lib/sensu/rabbitmq.rb

@@ -1,4 +1,4 @@
-gem 'amqp', '0.9.8'
+gem 'amqp', '0.9.9'
 
 require 'amqp'
 
@@ -35,7 +35,7 @@ module Sensu
         :on_tcp_connection_failure => on_failure,
         :on_possible_authentication_failure => on_failure
       })
-      @connection.logger = NullLogger.get
+      @connection.logger = Logger.get
       @connection.on_tcp_connection_loss do |connection, settings|
         unless connection.reconnecting?
           @before_reconnect.call

data/lib/sensu/server.rb

@@ -83,11 +83,11 @@ module Sensu
       @keepalive_queue = @amq.queue!('keepalives')
       @keepalive_queue.bind(@amq.direct('keepalives'))
       @keepalive_queue.subscribe(:ack => true) do |header, payload|
-        client = JSON.parse(payload, :symbolize_names => true)
+        client = Oj.load(payload)
         @logger.debug('received keepalive', {
           :client => client
         })
-        @redis.set('client:' + client[:name], client.to_json) do
+        @redis.set('client:' + client[:name], Oj.dump(client)) do
           @redis.sadd('clients', client[:name]) do
             header.ack
           end
@@ -100,10 +100,10 @@ module Sensu
       subdue_at = handler ? 'handler' : 'publisher'
       conditions = Array.new
       if check[:subdue]
-        conditions.push(check[:subdue])
+        conditions << check[:subdue]
       end
       if handler && handler[:subdue]
-        conditions.push(handler[:subdue])
+        conditions << handler[:subdue]
       end
       conditions.each do |condition|
         if condition.has_key?(:begin) && condition.has_key?(:end)
@@ -169,37 +169,26 @@ module Sensu
         filter[:negate] ? matched : !matched
       else
         @logger.error('unknown filter', {
-          :filter => {
-            :name => filter_name
-          }
+          :filter_name => filter_name
         })
         false
       end
     end
 
-    def derive_handlers(handler_list, nested=false)
+    def derive_handlers(handler_list)
       handler_list.inject(Array.new) do |handlers, handler_name|
         if @settings.handler_exists?(handler_name)
           handler = @settings[:handlers][handler_name].merge(:name => handler_name)
           if handler[:type] == 'set'
-            unless nested
-              handlers = handlers + derive_handlers(handler[:handlers], true)
-            else
-              @logger.error('handler sets cannot be nested', {
-                :handler => handler
-              })
-            end
+            handlers = handlers + derive_handlers(handler[:handlers])
           else
-            handlers.push(handler)
+            handlers << handler
           end
         elsif @extensions.handler_exists?(handler_name)
-          handler = @extensions[:handlers][handler_name]
-          handlers.push(handler)
+          handlers << @extensions[:handlers][handler_name]
         else
           @logger.error('unknown handler', {
-            :handler => {
-              :name => handler_name
-            }
+            :handler_name => handler_name
           })
         end
         handlers.uniq
@@ -284,7 +273,7 @@ module Sensu
     def mutate_event_data(mutator_name, event, &block)
       case
       when mutator_name.nil?
-        block.call(event.to_json)
+        block.call(Oj.dump(event))
       when @settings.mutator_exists?(mutator_name)
         mutator = @settings[:mutators][mutator_name]
         on_error = Proc.new do |error|
@@ -294,7 +283,7 @@ module Sensu
             :error => error.to_s
           })
         end
-        execute_command(mutator[:command], event.to_json, on_error) do |output, status|
+        execute_command(mutator[:command], Oj.dump(event), on_error) do |output, status|
           if status == 0
             block.call(output)
           else
@@ -316,9 +305,7 @@ module Sensu
         end
       else
         @logger.error('unknown mutator', {
-          :mutator => {
-            :name => mutator_name
-          }
+          :mutator_name => mutator_name
         })
       end
     end
@@ -403,10 +390,10 @@ module Sensu
       })
       check = result[:check]
       result_set = check[:name] + ':' + check[:issued].to_s
-      @redis.hset('aggregation:' + result_set, result[:client], {
+      @redis.hset('aggregation:' + result_set, result[:client], Oj.dump(
         :output => check[:output],
         :status => check[:status]
-      }.to_json) do
+      )) do
         SEVERITIES.each do |severity|
           @redis.hsetnx('aggregate:' + result_set, severity, 0)
         end
@@ -427,7 +414,7 @@ module Sensu
       })
       @redis.get('client:' + result[:client]) do |client_json|
         unless client_json.nil?
-          client = JSON.parse(client_json, :symbolize_names => true)
+          client = Oj.load(client_json)
           check = case
           when @settings.check_exists?(result[:check][:name])
             @settings[:checks][result[:check][:name]].merge(result[:check])
@@ -458,7 +445,7 @@ module Sensu
                 @redis.ltrim(history_key, -21, -1)
               end
               @redis.hget('events:' + client[:name], check[:name]) do |event_json|
-                previous_occurrence = event_json ? JSON.parse(event_json, :symbolize_names => true) : false
+                previous_occurrence = event_json ? Oj.load(event_json) : false
                 is_flapping = false
                 if check.has_key?(:low_flap_threshold) && check.has_key?(:high_flap_threshold)
                   was_flapping = previous_occurrence ? previous_occurrence[:flapping] : false
@@ -480,14 +467,14 @@ module Sensu
                   if previous_occurrence && check[:status] == previous_occurrence[:status]
                     event[:occurrences] = previous_occurrence[:occurrences] += 1
                   end
-                  @redis.hset('events:' + client[:name], check[:name], {
+                  @redis.hset('events:' + client[:name], check[:name], Oj.dump(
                     :output => check[:output],
                     :status => check[:status],
                     :issued => check[:issued],
                     :handlers => Array((check[:handlers] || check[:handler]) || 'default'),
                     :flapping => is_flapping,
                     :occurrences => event[:occurrences]
-                  }.to_json) do
+                  )) do
                     unless check[:handle] == false
                       event[:action] = is_flapping ? :flapping : :create
                       handle_event(event)
@@ -521,7 +508,7 @@ module Sensu
       @result_queue = @amq.queue!('results')
       @result_queue.bind(@amq.direct('results'))
       @result_queue.subscribe(:ack => true) do |header, payload|
-        result = JSON.parse(payload, :symbolize_names => true)
+        result = Oj.load(payload)
         @logger.debug('received result', {
           :result => result
         })
@@ -535,42 +522,52 @@ module Sensu
     def publish_check_request(check)
       payload = {
         :name => check[:name],
-        :command => check[:command],
         :issued => Time.now.to_i
       }
+      if check.has_key?(:command)
+        payload[:command] = check[:command]
+      end
       @logger.info('publishing check request', {
         :payload => payload,
         :subscribers => check[:subscribers]
       })
-      check[:subscribers].uniq.each do |exchange_name|
-        @amq.fanout(exchange_name).publish(payload.to_json)
+      check[:subscribers].each do |exchange_name|
+        @amq.fanout(exchange_name).publish(Oj.dump(payload))
       end
     end
 
-    def setup_publisher
-      @logger.debug('scheduling check requests')
+    def schedule_checks(checks)
       check_count = 0
       stagger = testing? ? 0 : 2
-      @settings.checks.each do |check|
-        unless check[:publish] == false || check[:standalone]
-          check_count += 1
-          scheduling_delay = stagger * check_count % 30
-          @master_timers << EM::Timer.new(scheduling_delay) do
-            interval = testing? ? 0.5 : check[:interval]
-            @master_timers << EM::PeriodicTimer.new(interval) do
-              unless action_subdued?(check)
-                publish_check_request(check)
-              else
-                @logger.info('action is subdued', {
-                  :check => check
-                })
-              end
+      checks.each do |check|
+        check_count += 1
+        scheduling_delay = stagger * check_count % 30
+        @master_timers << EM::Timer.new(scheduling_delay) do
+          interval = testing? ? 0.5 : check[:interval]
+          @master_timers << EM::PeriodicTimer.new(interval) do
+            unless action_subdued?(check)
+              publish_check_request(check)
+            else
+              @logger.info('check request was subdued', {
+                :check => check
+              })
             end
           end
         end
       end
     end
 
+    def setup_publisher
+      @logger.debug('scheduling check requests')
+      standard_checks = @settings.checks.reject do |check|
+        check[:standalone] || check[:publish] == false
+      end
+      extension_checks = @extensions.checks.reject do |check|
+        check[:standalone] || check[:publish] == false || !check[:interval].is_a?(Integer)
+      end
+      schedule_checks(standard_checks + extension_checks)
+    end
+
     def publish_result(client, check)
       payload = {
         :client => client[:name],
@@ -579,7 +576,7 @@ module Sensu
       @logger.info('publishing check result', {
         :payload => payload
       })
-      @amq.direct('results').publish(payload.to_json)
+      @amq.direct('results').publish(Oj.dump(payload))
     end
 
     def determine_stale_clients
@@ -587,7 +584,7 @@ module Sensu
       @redis.smembers('clients') do |clients|
         clients.each do |client_name|
           @redis.get('client:' + client_name) do |client_json|
-            client = JSON.parse(client_json, :symbolize_names => true)
+            client = Oj.load(client_json)
             check = {
               :name => 'keepalive',
               :issued => Time.now.to_i
@@ -821,8 +818,15 @@ module Sensu
     end
 
     def trap_signals
-      %w[INT TERM].each do |signal|
+      @signals = Array.new
+      STOP_SIGNALS.each do |signal|
         Signal.trap(signal) do
+          @signals << signal
+        end
+      end
+      EM::PeriodicTimer.new(1) do
+        signal = @signals.shift
+        if STOP_SIGNALS.include?(signal)
           @logger.warn('received signal', {
             :signal => signal
           })

data/lib/sensu/settings.rb

@@ -38,9 +38,17 @@ module Sensu
         end
       end
 
-      define_method((category.to_s.chop + '_exists?').to_sym) do |name|
+      type = category.to_s.chop
+
+      define_method((type + '_exists?').to_sym) do |name|
         @settings[category].has_key?(name.to_sym)
       end
+
+      define_method(('invalid_' + type).to_sym) do |details, reason|
+        invalid(reason, {
+          type => details
+        })
+      end
     end
 
     def load_env
@@ -70,10 +78,13 @@ module Sensu
     end
 
     def load_file(file)
+      @logger.debug('loading config file', {
+        :config_file => file
+      })
       if File.readable?(file)
         begin
           contents = File.open(file, 'r').read
-          config = JSON.parse(contents, :symbolize_names => true)
+          config = Oj.load(contents)
           merged = deep_merge(@settings, config)
           unless @loaded_files.empty?
             @logger.warn('config file applied changes', {
@@ -83,8 +94,8 @@ module Sensu
           end
           @settings = merged
           @indifferent_access = false
-          @loaded_files.push(file)
-        rescue JSON::ParserError => error
+          @loaded_files << file
+        rescue Oj::ParseError => error
           @logger.error('config file must be valid json', {
             :config_file => file,
             :error => error.to_s
@@ -116,40 +127,47 @@ module Sensu
 
     def validate
       @logger.debug('validating settings')
-      validate_checks
+      SETTINGS_CATEGORIES.each do |category|
+        unless @settings[category].is_a?(Hash)
+          invalid(category.to_s + ' must be a hash')
+        end
+        send(category).each do |details|
+          send(('validate_' + category.to_s.chop).to_sym, details)
+        end
+      end
       case File.basename($0)
-      when 'rspec'
-        validate_client
-        validate_api
-        validate_server
       when 'sensu-client'
         validate_client
       when 'sensu-api'
         validate_api
-      when 'sensu-server'
-        validate_server
+      when 'rspec'
+        validate_client
+        validate_api
       end
       @logger.debug('settings are valid')
     end
 
     private
 
-    def invalid(reason, details={})
+    def invalid(reason, data={})
       @logger.fatal('invalid settings', {
         :reason => reason
-      }.merge(details))
+      }.merge(data))
       @logger.fatal('SENSU NOT RUNNING!')
       exit 2
     end
 
-    def validate_subdue(condition, details={})
-      type = details.has_key?(:check) ? 'check' : 'handler'
+    def validate_subdue(type, details)
+      condition = details[:subdue]
+      data = {
+        type => details
+      }
       unless condition.is_a?(Hash)
-        invalid(type + ' subdue must be a hash', details)
+        invalid(type + ' subdue must be a hash', data)
       end
       if condition.has_key?(:at)
         unless %w[handler publisher].include?(condition[:at])
-          invalid(type + ' subdue at must be either handler or publisher', details)
+          invalid(type + ' subdue at must be either handler or publisher', data)
         end
       end
       if condition.has_key?(:begin) || condition.has_key?(:end)
@@ -157,117 +175,196 @@ module Sensu
           Time.parse(condition[:begin])
           Time.parse(condition[:end])
         rescue
-          invalid(type + ' subdue begin & end times must be valid', details)
+          invalid(type + ' subdue begin & end times must be valid', data)
         end
       end
       if condition.has_key?(:days)
         unless condition[:days].is_a?(Array)
-          invalid(type + ' subdue days must be an array', details)
+          invalid(type + ' subdue days must be an array', data)
         end
         condition[:days].each do |day|
           days = %w[sunday monday tuesday wednesday thursday friday saturday]
           unless day.is_a?(String) && days.include?(day.downcase)
-            invalid(type + ' subdue days must be valid days of the week', details)
+            invalid(type + ' subdue days must be valid days of the week', data)
           end
         end
       end
       if condition.has_key?(:exceptions)
         unless condition[:exceptions].is_a?(Array)
-          invalid(type + ' subdue exceptions must be an array', details)
+          invalid(type + ' subdue exceptions must be an array', data)
         end
         condition[:exceptions].each do |exception|
           unless exception.is_a?(Hash)
-            invalid(type + ' subdue exceptions must each be a hash', details)
+            invalid(type + ' subdue exceptions must each be a hash', data)
           end
           if exception.has_key?(:begin) || exception.has_key?(:end)
             begin
               Time.parse(exception[:begin])
               Time.parse(exception[:end])
             rescue
-              invalid(type + ' subdue exception begin & end times must be valid', details)
+              invalid(type + ' subdue exception begin & end times must be valid', data)
             end
           end
         end
       end
     end
 
-    def validate_checks
-      unless @settings[:checks].is_a?(Hash)
-        invalid('checks must be a hash')
-      end
-      checks.each do |check|
-        unless check[:interval].is_a?(Integer) && check[:interval] > 0
-          invalid('check is missing interval', {
-            :check => check
-          })
-        end
-        unless check[:command].is_a?(String)
-          invalid('check is missing command', {
-            :check => check
-          })
+    def validate_check(check)
+      unless check[:interval].is_a?(Integer) && check[:interval] > 0
+        invalid_check(check, 'check is missing interval')
+      end
+      unless check[:command].is_a?(String)
+        invalid_check(check, 'check is missing command')
+      end
+      unless check[:standalone]
+        unless check[:subscribers].is_a?(Array)
+          invalid_check(check, 'check is missing subscribers')
         end
-        unless check[:standalone]
-          unless check[:subscribers].is_a?(Array) && check[:subscribers].size > 0
-            invalid('check is missing subscribers', {
-              :check => check
-            })
+        check[:subscribers].each do |subscriber|
+          unless subscriber.is_a?(String) && !subscriber.empty?
+            invalid_check(check, 'check subscribers must each be a string')
           end
-          check[:subscribers].each do |subscriber|
-            unless subscriber.is_a?(String) && !subscriber.empty?
-              invalid('check subscribers must each be a string', {
-                :check => check
-              })
-            end
+        end
+      end
+      if check.has_key?(:timeout)
+        unless check[:timeout].is_a?(Numeric)
+          invalid_check(check, 'check timeout must be numeric')
+        end
+      end
+      if check.has_key?(:handler)
+        unless check[:handler].is_a?(String)
+          invalid_check(check, 'check handler must be a string')
+        end
+      end
+      if check.has_key?(:handlers)
+        unless check[:handlers].is_a?(Array)
+          invalid_check(check, 'check handlers must be an array')
+        end
+        check[:handlers].each do |handler_name|
+          unless handler_name.is_a?(String)
+            invalid_check(check, 'check handlers must each be a string')
           end
         end
-        if check.has_key?(:timeout)
-          unless check[:timeout].is_a?(Numeric)
-            invalid('check timeout must be numeric', {
-              :check => check
-            })
+      end
+      if check.has_key?(:low_flap_threshold) || check.has_key?(:high_flap_threshold)
+        unless check[:low_flap_threshold].is_a?(Integer)
+          invalid_check(check, 'check low flap threshold must be numeric')
+        end
+        unless check[:high_flap_threshold].is_a?(Integer)
+          invalid_check(check, 'check high flap threshold must be numeric')
+        end
+      end
+      if check.has_key?(:subdue)
+        validate_subdue('check', check)
+      end
+    end
+
+    def validate_mutator(mutator)
+      unless mutator[:command].is_a?(String)
+        invalid_mutator(mutator, 'mutator is missing command')
+      end
+    end
+
+    def validate_filter(filter)
+      unless filter[:attributes].is_a?(Hash)
+        invalid_filter(filter, 'filter attributes must be a hash')
+      end
+      if filter.has_key?(:negate)
+        unless !!filter[:negate] == filter[:negate]
+          invalid_filter(filter, 'filter negate must be boolean')
+        end
+      end
+    end
+
+    def validate_handler(handler)
+      unless handler[:type].is_a?(String)
+        invalid_handler(handler, 'handler is missing type')
+      end
+      case handler[:type]
+      when 'pipe'
+        unless handler[:command].is_a?(String)
+          invalid_handler(handler, 'handler is missing command')
+        end
+      when 'tcp', 'udp'
+        unless handler[:socket].is_a?(Hash)
+          invalid_handler(handler, 'handler is missing socket hash')
+        end
+        unless handler[:socket][:host].is_a?(String)
+          invalid_handler(handler, 'handler is missing socket host')
+        end
+        unless handler[:socket][:port].is_a?(Integer)
+          invalid_handler(handler, 'handler is missing socket port')
+        end
+        if handler[:socket].has_key?(:timeout)
+          unless handler[:socket][:timeout].is_a?(Integer)
+            invalid_handler(handler, 'handler socket timeout must be an integer')
           end
         end
-        if check.has_key?(:handler)
-          unless check[:handler].is_a?(String)
-            invalid('check handler must be a string', {
-              :check => check
-            })
+      when 'amqp'
+        unless handler[:exchange].is_a?(Hash)
+          invalid_handler(handler, 'handler is missing exchange hash')
+        end
+        unless handler[:exchange][:name].is_a?(String)
+          invalid_handler(handler, 'handler is missing exchange name')
+        end
+        if handler[:exchange].has_key?(:type)
+          unless %w[direct fanout topic].include?(handler[:exchange][:type])
+            invalid_handler(handler, 'handler exchange type is invalid')
           end
         end
-        if check.has_key?(:handlers)
-          unless check[:handlers].is_a?(Array)
-            invalid('check handlers must be an array', {
-              :check => check
-            })
+      when 'set'
+        unless handler[:handlers].is_a?(Array)
+          invalid_handler(handler, 'handler set handlers must be an array')
+        end
+        handler[:handlers].each do |handler_name|
+          unless handler_name.is_a?(String)
+            invalid_handler(handler, 'handler set handlers must each be a string')
           end
-          check[:handlers].each do |handler_name|
-            unless handler_name.is_a?(String)
-              invalid('check handlers items must be strings', {
-                :check => check
-              })
-            end
+          if handler_exists?(handler_name) && @settings[:handlers][handler_name.to_sym][:type] == 'set'
+            invalid_handler(handler, 'handler sets cannot be nested')
           end
         end
-        if check.has_key?(:low_flap_threshold)
-          unless check[:low_flap_threshold].is_a?(Integer)
-            invalid('flap thresholds must be integers', {
-              :check => check
-            })
-          end
+      else
+        invalid_handler(handler, 'unknown handler type')
+      end
+      if handler.has_key?(:filter)
+        unless handler[:filter].is_a?(String)
+          invalid_handler(handler, 'handler filter must be a string')
         end
-        if check.has_key?(:high_flap_threshold)
-          unless check[:high_flap_threshold].is_a?(Integer)
-            invalid('flap thresholds must be integers', {
-              :check => check
-            })
+      end
+      if handler.has_key?(:filters)
+        unless handler[:filters].is_a?(Array)
+          invalid_handler(handler, 'handler filters must be an array')
+        end
+        handler[:filters].each do |filter_name|
+          unless filter_name.is_a?(String)
+            invalid_handler(handler, 'handler filters items must be strings')
           end
         end
-        if check.has_key?(:subdue)
-          validate_subdue(check[:subdue], {
-            :check => check
-          })
+      end
+      if handler.has_key?(:mutator)
+        unless handler[:mutator].is_a?(String)
+          invalid_handler(handler, 'handler mutator must be a string')
+        end
+      end
+      if handler.has_key?(:handle_flapping)
+        unless !!handler[:handle_flapping] == handler[:handle_flapping]
+          invalid_handler(handler, 'handler handle_flapping must be boolean')
         end
       end
+      if handler.has_key?(:severities)
+        unless handler[:severities].is_a?(Array) && !handler[:severities].empty?
+          invalid_handler(handler, 'handler severities must be an array and not empty')
+        end
+        handler[:severities].each do |severity|
+          unless SEVERITIES.include?(severity)
+            invalid_handler(handler, 'handler severities are invalid')
+          end
+        end
+      end
+      if handler.has_key?(:subdue)
+        validate_subdue('handler', handler)
+      end
     end
 
     def validate_client
@@ -280,7 +377,7 @@ module Sensu
       unless @settings[:client][:address].is_a?(String)
         invalid('client must have an address')
       end
-      unless @settings[:client][:subscriptions].is_a?(Array) && !@settings[:client][:subscriptions].empty?
+      unless @settings[:client][:subscriptions].is_a?(Array)
         invalid('client must have subscriptions')
       end
       @settings[:client][:subscriptions].each do |subscription|
@@ -306,168 +403,5 @@ module Sensu
         end
       end
     end
-
-    def validate_server
-      unless @settings[:filters].is_a?(Hash)
-        invalid('filters must be a hash')
-      end
-      filters.each do |filter|
-        unless filter[:attributes].is_a?(Hash)
-          invalid('filter attributes must be a hash', {
-            :filter => filter
-          })
-        end
-        if filter.has_key?(:negate)
-          unless !!filter[:negate] == filter[:negate]
-            invalid('filter negate must be boolean', {
-              :filter => filter
-            })
-          end
-        end
-      end
-      unless @settings[:mutators].is_a?(Hash)
-        invalid('mutators must be a hash')
-      end
-      mutators.each do |mutator|
-        unless mutator[:command].is_a?(String)
-          invalid('mutator is missing command', {
-            :mutator => mutator
-          })
-        end
-      end
-      unless @settings[:handlers].is_a?(Hash)
-        invalid('handlers must be a hash')
-      end
-      unless @settings[:handlers].include?(:default)
-        invalid('missing default handler')
-      end
-      handlers.each do |handler|
-        unless handler[:type].is_a?(String)
-          invalid('handler is missing type', {
-            :handler => handler
-          })
-        end
-        case handler[:type]
-        when 'pipe'
-          unless handler[:command].is_a?(String)
-            invalid('handler is missing command', {
-              :handler => handler
-            })
-          end
-        when 'tcp', 'udp'
-          unless handler[:socket].is_a?(Hash)
-            invalid('handler is missing socket hash', {
-              :handler => handler
-            })
-          end
-          unless handler[:socket][:host].is_a?(String)
-            invalid('handler is missing socket host', {
-              :handler => handler
-            })
-          end
-          unless handler[:socket][:port].is_a?(Integer)
-            invalid('handler is missing socket port', {
-              :handler => handler
-            })
-          end
-          if handler[:socket].has_key?(:timeout)
-            unless handler[:socket][:timeout].is_a?(Integer)
-              invalid('handler socket timeout must be an integer', {
-                :handler => handler
-              })
-            end
-          end
-        when 'amqp'
-          unless handler[:exchange].is_a?(Hash)
-            invalid('handler is missing exchange hash', {
-              :handler => handler
-            })
-          end
-          unless handler[:exchange][:name].is_a?(String)
-            invalid('handler is missing exchange name', {
-              :handler => handler
-            })
-          end
-          if handler[:exchange].has_key?(:type)
-            unless %w[direct fanout topic].include?(handler[:exchange][:type])
-              invalid('handler exchange type is invalid', {
-                :handler => handler
-              })
-            end
-          end
-        when 'set'
-          unless handler[:handlers].is_a?(Array)
-            invalid('handler set handlers must be an array', {
-              :handler => handler
-            })
-          end
-          handler[:handlers].each do |handler_name|
-            unless handler_name.is_a?(String)
-              invalid('handler set handlers items must be strings', {
-                :handler => handler
-              })
-            end
-          end
-        else
-          invalid('unknown handler type', {
-            :handler => handler
-          })
-        end
-        if handler.has_key?(:filter)
-          unless handler[:filter].is_a?(String)
-            invalid('handler filter must be a string', {
-              :handler => handler
-            })
-          end
-        end
-        if handler.has_key?(:filters)
-          unless handler[:filters].is_a?(Array)
-            invalid('handler filters must be an array', {
-              :handler => handler
-            })
-          end
-          handler[:filters].each do |filter_name|
-            unless filter_name.is_a?(String)
-              invalid('handler filters items must be strings', {
-                :handler => handler
-              })
-            end
-          end
-        end
-        if handler.has_key?(:mutator)
-          unless handler[:mutator].is_a?(String)
-            invalid('handler mutator must be a string', {
-              :handler => handler
-            })
-          end
-        end
-        if handler.has_key?(:handle_flapping)
-          unless !!handler[:handle_flapping] == handler[:handle_flapping]
-            invalid('handler handle_flapping must be boolean', {
-              :handler => handler
-            })
-          end
-        end
-        if handler.has_key?(:severities)
-          unless handler[:severities].is_a?(Array) && !handler[:severities].empty?
-            invalid('handler severities must be an array and not empty', {
-              :handler => handler
-            })
-          end
-          handler[:severities].each do |severity|
-            unless SEVERITIES.include?(severity)
-              invalid('handler severities are invalid', {
-                :handler => handler
-              })
-            end
-          end
-        end
-        if handler.has_key?(:subdue)
-          validate_subdue(handler[:subdue], {
-            :handler => handler
-          })
-        end
-      end
-    end
   end
 end