sensu 0.12.6 → 0.13.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e1b021d3461d4daef8432adea63250ae659bb10
+  data.tar.gz: b00ffdcb7989eba387b66777b5b6cd04abf1264d
+SHA512:
+  metadata.gz: d324be84c52252df92c88c1e1691a4917aba28c29c520a482ea27b4c46c7c3fcfe30a569cde6cd6464ecaecf631fee7f86b9cc99186ec5d6725cb27a8c9af7f0
+  data.tar.gz: 1c0d83d4bcf511709f0abed6624e293ad5037a32e3f221225c46247ebef1284fc5a332aaa3013b951b075b4233c85a9bdb3e94f9e1f60338a3a1f5da4ec07094

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## 0.13.0 - TBD
+
+### Non-backwards compatible changes
+
+API GET /events now provides all event data, the same data passed to event
+handlers.
+
+Standalone check results are no longer merged with check definitions
+residing on the server(s).
+
+Removed the generic extension type.
+
+Extension stop() no longer takes a callback, and is called when the
+eventmachine reactor is stopped.
+
+### Features
+
+Abstracted the transport layer, opening Sensu up to alternative messaging
+services.
+
+Event bridge extension type, allowing all events to be relayed to other
+services.
+
+Client keepalives now contain the Sensu version.
+
+### Other
+
+Clients now only load instances of check extensions, and servers load
+everything but check extensions.
+
+Fixed standalone check scheduling, no longer mutating definitions.
+
+Fixed command token substitution, allowing for the use of colons.
+
+Log events are flushed when the eventmachine reactor stops.
+
+Dropped the Oj JSON parser, heap allocation issues and memory leaks.
+
+Client RabbitMQ queues are no longer server named (bugs), they are now
+composed of the client name, Sensu version, and the timestamp at creation.
+
 ## 0.12.6 - 2014-02-19
 
 ### Non-backwards compatible changes

data/lib/sensu/api.rb

@@ -1,5 +1,4 @@
-require File.join(File.dirname(__FILE__), 'base')
-require File.join(File.dirname(__FILE__), 'redis')
+require 'sensu/daemon'
 
 gem 'thin', '1.5.0'
 gem 'sinatra', '1.3.5'
@@ -13,97 +12,45 @@ module Sensu
     register Sinatra::Async
 
     class << self
+      include Daemon
+
       def run(options={})
+        bootstrap(options)
         EM::run do
-          bootstrap(options)
           start
-          trap_signals
+          setup_signal_traps
         end
       end
 
-      def bootstrap(options={})
-        base = Base.new(options)
-        $logger = base.logger
-        $settings = base.settings
-        base.setup_process
-        if $settings[:api][:user] && $settings[:api][:password]
+      def bootstrap(options)
+        setup_logger(options)
+        set :logger, @logger
+        load_settings(options)
+        if @settings[:api][:user] && @settings[:api][:password]
           use Rack::Auth::Basic do |user, password|
-            user == $settings[:api][:user] && password == $settings[:api][:password]
+            user == @settings[:api][:user] && password == @settings[:api][:password]
           end
         end
-      end
-
-      def setup_redis
-        $logger.debug('connecting to redis', {
-          :settings => $settings[:redis]
-        })
-        $redis = Redis.connect($settings[:redis])
-        $redis.on_error do |error|
-          $logger.fatal('redis connection error', {
-            :error => error.to_s
-          })
-          stop
-        end
-        $redis.before_reconnect do
-          $logger.warn('reconnecting to redis')
-        end
-        $redis.after_reconnect do
-          $logger.info('reconnected to redis')
-        end
-      end
-
-      def setup_rabbitmq
-        $logger.debug('connecting to rabbitmq', {
-          :settings => $settings[:rabbitmq]
-        })
-        $rabbitmq = RabbitMQ.connect($settings[:rabbitmq])
-        $rabbitmq.on_error do |error|
-          $logger.fatal('rabbitmq connection error', {
-            :error => error.to_s
-          })
-          stop
-        end
-        $rabbitmq.before_reconnect do
-          $logger.warn('reconnecting to rabbitmq')
-        end
-        $rabbitmq.after_reconnect do
-          $logger.info('reconnected to rabbitmq')
-        end
-        $amq = $rabbitmq.channel
+        set :checks, @settings[:checks]
+        set :all_checks, @settings.checks
+        setup_process(options)
       end
 
       def start
         setup_redis
-        setup_rabbitmq
+        set :redis, @redis
+        setup_transport
+        set :transport, @transport
         Thin::Logging.silent = true
-        bind = $settings[:api][:bind] || '0.0.0.0'
-        Thin::Server.start(bind, $settings[:api][:port], self)
+        bind = @settings[:api][:bind] || '0.0.0.0'
+        Thin::Server.start(bind, @settings[:api][:port], self)
       end
 
       def stop
-        $logger.warn('stopping')
-        $rabbitmq.close
-        $redis.close
-        $logger.warn('stopping reactor')
-        EM::stop_event_loop
-      end
-
-      def trap_signals
-        $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
-            })
-            stop
-          end
-        end
+        @logger.warn('stopping')
+        @redis.close
+        @transport.close
+        super
       end
 
       def test(options={})
@@ -127,7 +74,7 @@ module Sensu
 
     helpers do
       def request_log_line
-        $logger.info([env['REQUEST_METHOD'], env['REQUEST_PATH']].join(' '), {
+        settings.logger.info([env['REQUEST_METHOD'], env['REQUEST_PATH']].join(' '), {
           :remote_address => env['REMOTE_ADDR'],
           :user_agent => env['HTTP_USER_AGENT'],
           :request_method => env['REQUEST_METHOD'],
@@ -160,7 +107,7 @@ module Sensu
       end
 
       def issued!
-        accepted!(Oj.dump(:issued => Time.now.to_i))
+        accepted!(MultiJson.dump(:issued => Time.now.to_i))
       end
 
       def no_content!
@@ -170,7 +117,7 @@ module Sensu
 
       def read_data(rules={}, &block)
         begin
-          data = Oj.load(env['rack.input'].read)
+          data = MultiJson.load(env['rack.input'].read)
           valid = rules.all? do |key, rule|
             data[key].is_a?(rule[:type]) || (rule[:nil_ok] && data[key].nil?)
           end
@@ -179,7 +126,7 @@ module Sensu
           else
             bad_request!
           end
-        rescue Oj::ParseError
+        rescue MultiJson::ParseError
           bad_request!
         end
       end
@@ -192,7 +139,7 @@ module Sensu
         limit = integer_parameter(params[:limit])
         offset = integer_parameter(params[:offset]) || 0
         unless limit.nil?
-          headers['X-Pagination'] = Oj.dump(
+          headers['X-Pagination'] = MultiJson.dump(
             :limit => limit,
             :offset => offset,
             :total => items.size
@@ -204,7 +151,7 @@ module Sensu
         end
       end
 
-      def rabbitmq_info(&block)
+      def transport_info(&block)
         info = {
           :keepalives => {
             :messages => nil,
@@ -214,15 +161,13 @@ module Sensu
             :messages => nil,
             :consumers => nil
           },
-          :connected => $rabbitmq.connected?
+          :connected => settings.transport.connected?
         }
-        if $rabbitmq.connected?
-          $amq.queue('keepalives', :auto_delete => true).status do |messages, consumers|
-            info[:keepalives][:messages] = messages
-            info[:keepalives][:consumers] = consumers
-            $amq.queue('results', :auto_delete => true).status do |messages, consumers|
-              info[:results][:messages] = messages
-              info[:results][:consumers] = consumers
+        if settings.transport.connected?
+          settings.transport.stats('keepalives') do |stats|
+            info[:keepalives] = stats
+            settings.transport.stats('results') do |stats|
+              info[:results] = stats
               block.call(info)
             end
           end
@@ -231,35 +176,30 @@ module Sensu
         end
       end
 
-      def event_hash(event_json, client_name, check_name)
-        Oj.load(event_json).merge(
-          :client => client_name,
-          :check => check_name
+      def resolve_event(event_json)
+        event = MultiJson.load(event_json)
+        check = event[:check].merge(
+          :output => 'Resolving on request of the API',
+          :status => 0,
+          :issued => Time.now.to_i,
+          :executed => Time.now.to_i,
+          :force_resolve => true
         )
-      end
-
-      def resolve_event(event)
+        check.delete(:history)
         payload = {
-          :client => event[:client],
-          :check => {
-            :name => event[:check],
-            :output => 'Resolving on request of the API',
-            :status => 0,
-            :issued => Time.now.to_i,
-            :handlers => event[:handlers],
-            :force_resolve => true
-          }
+          :client => event[:client][:name],
+          :check => check
         }
-        $logger.info('publishing check result', {
+        settings.logger.info('publishing check result', {
           :payload => payload
         })
-        begin
-          $amq.direct('results').publish(Oj.dump(payload))
-        rescue AMQ::Client::ConnectionClosedError => error
-          $logger.error('failed to publish check result', {
-            :payload => payload,
-            :error => error.to_s
-          })
+        settings.transport.publish(:direct, 'results', MultiJson.dump(payload)) do |info|
+          if info[:error]
+            settings.logger.error('failed to publish check result', {
+              :payload => payload,
+              :error => info[:error].to_s
+            })
+          end
         end
       end
     end
@@ -270,26 +210,26 @@ module Sensu
     end
 
     aget '/info/?' do
-      rabbitmq_info do |info|
+      transport_info do |info|
         response = {
           :sensu => {
             :version => VERSION
           },
-          :rabbitmq => info,
+          :transport => info,
           :redis => {
-            :connected => $redis.connected?
+            :connected => settings.redis.connected?
           }
         }
-        body Oj.dump(response)
+        body MultiJson.dump(response)
       end
     end
 
     aget '/health/?' do
-      if $redis.connected? && $rabbitmq.connected?
+      if settings.redis.connected? && settings.transport.connected?
         healthy = Array.new
         min_consumers = integer_parameter(params[:consumers])
         max_messages = integer_parameter(params[:messages])
-        rabbitmq_info do |info|
+        transport_info do |info|
           if min_consumers
             healthy << (info[:keepalives][:consumers] >= min_consumers)
             healthy << (info[:results][:consumers] >= min_consumers)
@@ -307,25 +247,25 @@ module Sensu
 
     aget '/clients/?' do
       response = Array.new
-      $redis.smembers('clients') do |clients|
+      settings.redis.smembers('clients') do |clients|
         clients = pagination(clients)
         unless clients.empty?
           clients.each_with_index do |client_name, index|
-            $redis.get('client:' + client_name) do |client_json|
-              response << Oj.load(client_json)
+            settings.redis.get('client:' + client_name) do |client_json|
+              response << MultiJson.load(client_json)
               if index == clients.size - 1
-                body Oj.dump(response)
+                body MultiJson.dump(response)
               end
             end
           end
         else
-          body Oj.dump(response)
+          body MultiJson.dump(response)
         end
       end
     end
 
     aget %r{/clients?/([\w\.-]+)/?$} do |client_name|
-      $redis.get('client:' + client_name) do |client_json|
+      settings.redis.get('client:' + client_name) do |client_json|
         unless client_json.nil?
           body client_json
         else
@@ -336,16 +276,16 @@ module Sensu
 
     aget %r{/clients/([\w\.-]+)/history/?$} do |client_name|
       response = Array.new
-      $redis.smembers('history:' + client_name) do |checks|
+      settings.redis.smembers('history:' + client_name) do |checks|
         unless checks.empty?
           checks.each_with_index do |check_name, index|
             history_key = 'history:' + client_name + ':' + check_name
-            $redis.lrange(history_key, -21, -1) do |history|
+            settings.redis.lrange(history_key, -21, -1) do |history|
               history.map! do |status|
                 status.to_i
               end
               execution_key = 'execution:' + client_name + ':' + check_name
-              $redis.get(execution_key) do |last_execution|
+              settings.redis.get(execution_key) do |last_execution|
                 unless history.empty? || last_execution.nil?
                   item = {
                     :check => check_name,
@@ -356,38 +296,38 @@ module Sensu
                   response << item
                 end
                 if index == checks.size - 1
-                  body Oj.dump(response)
+                  body MultiJson.dump(response)
                 end
               end
             end
           end
         else
-          body Oj.dump(response)
+          body MultiJson.dump(response)
         end
       end
     end
 
     adelete %r{/clients?/([\w\.-]+)/?$} do |client_name|
-      $redis.get('client:' + client_name) do |client_json|
+      settings.redis.get('client:' + client_name) do |client_json|
         unless client_json.nil?
-          $redis.hgetall('events:' + client_name) do |events|
+          settings.redis.hgetall('events:' + client_name) do |events|
             events.each do |check_name, event_json|
-              resolve_event(event_hash(event_json, client_name, check_name))
+              resolve_event(event_json)
             end
             EM::Timer.new(5) do
-              client = Oj.load(client_json)
-              $logger.info('deleting client', {
+              client = MultiJson.load(client_json)
+              settings.logger.info('deleting client', {
                 :client => client
               })
-              $redis.srem('clients', client_name) do
-                $redis.del('client:' + client_name)
-                $redis.del('events:' + client_name)
-                $redis.smembers('history:' + client_name) do |checks|
+              settings.redis.srem('clients', client_name) do
+                settings.redis.del('client:' + client_name)
+                settings.redis.del('events:' + client_name)
+                settings.redis.smembers('history:' + client_name) do |checks|
                   checks.each do |check_name|
-                    $redis.del('history:' + client_name + ':' + check_name)
-                    $redis.del('execution:' + client_name + ':' + check_name)
+                    settings.redis.del('history:' + client_name + ':' + check_name)
+                    settings.redis.del('execution:' + client_name + ':' + check_name)
                   end
-                  $redis.del('history:' + client_name)
+                  settings.redis.del('history:' + client_name)
                 end
               end
             end
@@ -400,13 +340,13 @@ module Sensu
     end
 
     aget '/checks/?' do
-      body Oj.dump($settings.checks)
+      body MultiJson.dump(settings.all_checks)
     end
 
     aget %r{/checks?/([\w\.-]+)/?$} do |check_name|
-      if $settings.check_exists?(check_name)
-        response = $settings[:checks][check_name].merge(:name => check_name)
-        body Oj.dump(response)
+      if settings.checks[check_name]
+        response = settings.checks[check_name].merge(:name => check_name)
+        body MultiJson.dump(response)
       else
         not_found!
       end
@@ -418,27 +358,27 @@ module Sensu
         :subscribers => {:type => Array, :nil_ok => true}
       }
       read_data(rules) do |data|
-        if $settings.check_exists?(data[:check])
-          check = $settings[:checks][data[:check]]
+        if settings.checks[data[:check]]
+          check = settings.checks[data[:check]]
           subscribers = data[:subscribers] || check[:subscribers] || Array.new
           payload = {
             :name => data[:check],
             :command => check[:command],
             :issued => Time.now.to_i
           }
-          $logger.info('publishing check request', {
+          settings.logger.info('publishing check request', {
             :payload => payload,
             :subscribers => subscribers
           })
           subscribers.uniq.each do |exchange_name|
-            begin
-              $amq.fanout(exchange_name).publish(Oj.dump(payload))
-            rescue AMQ::Client::ConnectionClosedError => error
-              $logger.error('failed to publish check request', {
-                :exchange_name => exchange_name,
-                :payload => payload,
-                :error => error.to_s
-              })
+            settings.transport.publish(:fanout, exchange_name, MultiJson.dump(payload)) do |info|
+              if info[:error]
+                settings.logger.error('failed to publish check request', {
+                  :exchange_name => exchange_name,
+                  :payload => payload,
+                  :error => info[:error].to_s
+                })
+              end
             end
           end
           issued!
@@ -450,39 +390,39 @@ module Sensu
 
     aget '/events/?' do
       response = Array.new
-      $redis.smembers('clients') do |clients|
+      settings.redis.smembers('clients') do |clients|
         unless clients.empty?
           clients.each_with_index do |client_name, index|
-            $redis.hgetall('events:' + client_name) do |events|
+            settings.redis.hgetall('events:' + client_name) do |events|
               events.each do |check_name, event_json|
-                response << event_hash(event_json, client_name, check_name)
+                response << MultiJson.load(event_json)
               end
               if index == clients.size - 1
-                body Oj.dump(response)
+                body MultiJson.dump(response)
               end
             end
           end
         else
-          body Oj.dump(response)
+          body MultiJson.dump(response)
         end
       end
     end
 
     aget %r{/events/([\w\.-]+)/?$} do |client_name|
       response = Array.new
-      $redis.hgetall('events:' + client_name) do |events|
+      settings.redis.hgetall('events:' + client_name) do |events|
         events.each do |check_name, event_json|
-          response << event_hash(event_json, client_name, check_name)
+          response << MultiJson.load(event_json)
         end
-        body Oj.dump(response)
+        body MultiJson.dump(response)
       end
     end
 
     aget %r{/events?/([\w\.-]+)/([\w\.-]+)/?$} do |client_name, check_name|
-      $redis.hgetall('events:' + client_name) do |events|
+      settings.redis.hgetall('events:' + client_name) do |events|
         event_json = events[check_name]
         unless event_json.nil?
-          body Oj.dump(event_hash(event_json, client_name, check_name))
+          body event_json
         else
           not_found!
         end
@@ -490,9 +430,9 @@ module Sensu
     end
 
     adelete %r{/events?/([\w\.-]+)/([\w\.-]+)/?$} do |client_name, check_name|
-      $redis.hgetall('events:' + client_name) do |events|
+      settings.redis.hgetall('events:' + client_name) do |events|
         if events.include?(check_name)
-          resolve_event(event_hash(events[check_name], client_name, check_name))
+          resolve_event(events[check_name])
           issued!
         else
           not_found!
@@ -506,9 +446,9 @@ module Sensu
         :check => {:type => String, :nil_ok => false}
       }
       read_data(rules) do |data|
-        $redis.hgetall('events:' + data[:client]) do |events|
+        settings.redis.hgetall('events:' + data[:client]) do |events|
           if events.include?(data[:check])
-            resolve_event(event_hash(events[data[:check]], data[:client], data[:check]))
+            resolve_event(events[data[:check]])
             issued!
           else
             not_found!
@@ -519,10 +459,10 @@ module Sensu
 
     aget '/aggregates/?' do
       response = Array.new
-      $redis.smembers('aggregates') do |checks|
+      settings.redis.smembers('aggregates') do |checks|
         unless checks.empty?
           checks.each_with_index do |check_name, index|
-            $redis.smembers('aggregates:' + check_name) do |aggregates|
+            settings.redis.smembers('aggregates:' + check_name) do |aggregates|
               aggregates.reverse!
               aggregates.map! do |issued|
                 issued.to_i
@@ -533,18 +473,18 @@ module Sensu
               }
               response << item
               if index == checks.size - 1
-                body Oj.dump(response)
+                body MultiJson.dump(response)
               end
             end
           end
         else
-          body Oj.dump(response)
+          body MultiJson.dump(response)
         end
       end
     end
 
     aget %r{/aggregates/([\w\.-]+)/?$} do |check_name|
-      $redis.smembers('aggregates:' + check_name) do |aggregates|
+      settings.redis.smembers('aggregates:' + check_name) do |aggregates|
         unless aggregates.empty?
           aggregates.reverse!
           aggregates.map! do |issued|
@@ -557,7 +497,7 @@ module Sensu
               issued > timestamp
             end
           end
-          body Oj.dump(pagination(aggregates))
+          body MultiJson.dump(pagination(aggregates))
         else
           not_found!
         end
@@ -565,15 +505,15 @@ module Sensu
     end
 
     adelete %r{/aggregates/([\w\.-]+)/?$} do |check_name|
-      $redis.smembers('aggregates:' + check_name) do |aggregates|
+      settings.redis.smembers('aggregates:' + check_name) do |aggregates|
         unless aggregates.empty?
           aggregates.each do |check_issued|
             result_set = check_name + ':' + check_issued
-            $redis.del('aggregation:' + result_set)
-            $redis.del('aggregate:' + result_set)
+            settings.redis.del('aggregation:' + result_set)
+            settings.redis.del('aggregate:' + result_set)
           end
-          $redis.del('aggregates:' + check_name) do
-            $redis.srem('aggregates', check_name) do
+          settings.redis.del('aggregates:' + check_name) do
+            settings.redis.srem('aggregates', check_name) do
               no_content!
             end
           end
@@ -585,15 +525,15 @@ module Sensu
 
     aget %r{/aggregates?/([\w\.-]+)/([\w\.-]+)/?$} do |check_name, check_issued|
       result_set = check_name + ':' + check_issued
-      $redis.hgetall('aggregate:' + result_set) do |aggregate|
+      settings.redis.hgetall('aggregate:' + result_set) do |aggregate|
         unless aggregate.empty?
           response = aggregate.inject(Hash.new) do |totals, (status, count)|
             totals[status] = Integer(count)
             totals
           end
-          $redis.hgetall('aggregation:' + result_set) do |results|
+          settings.redis.hgetall('aggregation:' + result_set) do |results|
             parsed_results = results.inject(Array.new) do |parsed, (client_name, check_json)|
-              check = Oj.load(check_json)
+              check = MultiJson.load(check_json)
               parsed << check.merge(:client => client_name)
             end
             if params[:summarize]
@@ -609,7 +549,7 @@ module Sensu
             if params[:results]
               response[:results] = parsed_results
             end
-            body Oj.dump(response)
+            body MultiJson.dump(response)
           end
         else
           not_found!
@@ -619,16 +559,16 @@ module Sensu
 
     apost %r{/stash(?:es)?/(.*)/?} do |path|
       read_data do |data|
-        $redis.set('stash:' + path, Oj.dump(data)) do
-          $redis.sadd('stashes', path) do
-            created!(Oj.dump(:path => path))
+        settings.redis.set('stash:' + path, MultiJson.dump(data)) do
+          settings.redis.sadd('stashes', path) do
+            created!(MultiJson.dump(:path => path))
           end
         end
       end
     end
 
     aget %r{/stash(?:es)?/(.*)/?} do |path|
-      $redis.get('stash:' + path) do |stash_json|
+      settings.redis.get('stash:' + path) do |stash_json|
         unless stash_json.nil?
           body stash_json
         else
@@ -638,10 +578,10 @@ module Sensu
     end
 
     adelete %r{/stash(?:es)?/(.*)/?} do |path|
-      $redis.exists('stash:' + path) do |stash_exists|
+      settings.redis.exists('stash:' + path) do |stash_exists|
         if stash_exists
-          $redis.srem('stashes', path) do
-            $redis.del('stash:' + path) do
+          settings.redis.srem('stashes', path) do
+            settings.redis.del('stash:' + path) do
               no_content!
             end
           end
@@ -653,29 +593,29 @@ module Sensu
 
     aget '/stashes/?' do
       response = Array.new
-      $redis.smembers('stashes') do |stashes|
+      settings.redis.smembers('stashes') do |stashes|
         unless stashes.empty?
           stashes.each_with_index do |path, index|
-            $redis.get('stash:' + path) do |stash_json|
-              $redis.ttl('stash:' + path) do |ttl|
+            settings.redis.get('stash:' + path) do |stash_json|
+              settings.redis.ttl('stash:' + path) do |ttl|
                 unless stash_json.nil?
                   item = {
                     :path => path,
-                    :content => Oj.load(stash_json),
+                    :content => MultiJson.load(stash_json),
                     :expire => ttl
                   }
                   response << item
                 else
-                  $redis.srem('stashes', path)
+                  settings.redis.srem('stashes', path)
                 end
                 if index == stashes.size - 1
-                  body Oj.dump(pagination(response))
+                  body MultiJson.dump(pagination(response))
                 end
               end
             end
           end
         else
-          body Oj.dump(response)
+          body MultiJson.dump(response)
         end
       end
     end
@@ -688,11 +628,11 @@ module Sensu
       }
       read_data(rules) do |data|
         stash_key = 'stash:' + data[:path]
-        $redis.set(stash_key, Oj.dump(data[:content])) do
-          $redis.sadd('stashes', data[:path]) do
-            response = Oj.dump(:path => data[:path])
+        settings.redis.set(stash_key, MultiJson.dump(data[:content])) do
+          settings.redis.sadd('stashes', data[:path]) do
+            response = MultiJson.dump(:path => data[:path])
             if data[:expire]
-              $redis.expire(stash_key, data[:expire]) do
+              settings.redis.expire(stash_key, data[:expire]) do
                 created!(response)
               end
             else