sensu 0.22.2 → 0.23.0.beta

data/lib/sensu/client/process.rb

@@ -51,7 +51,7 @@ module Sensu
       def publish_keepalive
         payload = keepalive_payload
         @logger.debug("publishing keepalive", :payload => payload)
-        @transport.publish(:direct, "keepalives", MultiJson.dump(payload)) do |info|
+        @transport.publish(:direct, "keepalives", Sensu::JSON.dump(payload)) do |info|
           if info[:error]
             @logger.error("failed to publish keepalive", {
               :payload => payload,
@@ -89,7 +89,7 @@ module Sensu
         }
         payload[:signature] = @settings[:client][:signature] if @settings[:client][:signature]
         @logger.info("publishing check result", :payload => payload)
-        @transport.publish(:direct, "results", MultiJson.dump(payload)) do |info|
+        @transport.publish(:direct, "results", Sensu::JSON.dump(payload)) do |info|
           if info[:error]
             @logger.error("failed to publish check result", {
               :payload => payload,
@@ -99,42 +99,6 @@ module Sensu
         end
       end
 
-      # Traverse the Sensu client definition (hash) for an attribute
-      # value, with a fallback default value if nil.
-      #
-      # @param tree [Hash] to traverse.
-      # @param path [Array] of attribute keys.
-      # @param default [Object] value if attribute value is nil.
-      # @return [Object] attribute or fallback default value.
-      def find_client_attribute(tree, path, default)
-        attribute = tree[path.shift]
-        if attribute.is_a?(Hash)
-          find_client_attribute(attribute, path, default)
-        else
-          attribute.nil? ? default : attribute
-        end
-      end
-
-      # Substitue check command tokens (eg. :::db.name|production:::)
-      # with the associated client definition attribute value. Command
-      # tokens can provide a fallback default value, following a pipe.
-      #
-      # @param check [Hash]
-      # @return [Array] containing the check command string with
-      #   tokens substituted and an array of unmatched command tokens.
-      def substitute_check_command_tokens(check)
-        unmatched_tokens = []
-        substituted = check[:command].gsub(/:::([^:].*?):::/) do
-          token, default = $1.to_s.split("|", -1)
-          matched = find_client_attribute(@settings[:client], token.split("."), default)
-          if matched.nil?
-            unmatched_tokens << token
-          end
-          matched
-        end
-        [substituted, unmatched_tokens]
-      end
-
       # Execute a check command, capturing its output (STDOUT/ERR),
       # exit status code, execution duration, timestamp, and publish
       # the result. This method guards against multiple executions for
@@ -149,7 +113,7 @@ module Sensu
         @logger.debug("attempting to execute check command", :check => check)
         unless @checks_in_progress.include?(check[:name])
           @checks_in_progress << check[:name]
-          command, unmatched_tokens = substitute_check_command_tokens(check)
+          command, unmatched_tokens = substitute_tokens(check[:command], @settings[:client])
           if unmatched_tokens.empty?
             check[:executed] = Time.now.to_i
             started = Time.now.to_f
@@ -273,10 +237,10 @@ module Sensu
           options = transport_subscribe_options(subscription)
           @transport.subscribe(*options) do |message_info, message|
             begin
-              check = MultiJson.load(message)
+              check = Sensu::JSON.load(message)
               @logger.info("received check request", :check => check)
               process_check_request(check)
-            rescue MultiJson::ParseError => error
+            rescue Sensu::JSON::ParseError => error
               @logger.error("failed to parse the check request payload", {
                 :message => message,
                 :error => error.to_s
@@ -412,9 +376,10 @@ module Sensu
       # transport connection, the sockets, and calling the
       # `bootstrap()` method.
       def start
-        setup_transport
-        setup_sockets
-        bootstrap
+        setup_transport do
+          setup_sockets
+          bootstrap
+        end
       end
 
       # Pause the Sensu client process, unless it is being paused or

data/lib/sensu/client/socket.rb

@@ -1,4 +1,4 @@
-require "multi_json"
+require "sensu/json"
 
 module Sensu
   module Client
@@ -145,7 +145,7 @@ module Sensu
           :check => check.merge(:issued => Time.now.to_i)
         }
         @logger.info("publishing check result", :payload => payload)
-        @transport.publish(:direct, "results", MultiJson.dump(payload))
+        @transport.publish(:direct, "results", Sensu::JSON.dump(payload))
       end
 
       # Process a check result. Set check result attribute defaults,
@@ -169,10 +169,10 @@ module Sensu
       # @param [String] data to parse for a check result.
       def parse_check_result(data)
         begin
-          check = MultiJson.load(data)
+          check = Sensu::JSON.load(data)
           cancel_watchdog
           process_check_result(check)
-        rescue MultiJson::ParseError, ArgumentError => error
+        rescue Sensu::JSON::ParseError, ArgumentError => error
           if @protocol == :tcp
             @parse_error = error.to_s
           else

data/lib/sensu/constants.rb

@@ -1,7 +1,7 @@
 module Sensu
   unless defined?(Sensu::VERSION)
     # Sensu release version.
-    VERSION = "0.22.2".freeze
+    VERSION = "0.23.0.beta".freeze
 
     # Sensu check severities.
     SEVERITIES = %w[ok warning critical unknown].freeze

data/lib/sensu/daemon.rb

@@ -1,31 +1,30 @@
 require "rubygems"
 
-gem "multi_json", "1.11.2"
-gem "eventmachine", "1.0.9.1"
+gem "eventmachine", "1.2.0.1"
 
-gem "sensu-logger", "1.1.0"
-gem "sensu-settings", "3.3.0"
+gem "sensu-json", "1.1.0"
+gem "sensu-logger", "1.2.0"
+gem "sensu-settings", "3.4.0"
 gem "sensu-extension", "1.5.0"
-gem "sensu-extensions", "1.4.0"
-gem "sensu-transport", "4.0.0"
+gem "sensu-extensions", "1.5.0"
+gem "sensu-transport", "5.0.0"
 gem "sensu-spawn", "1.8.0"
+gem "sensu-redis", "1.2.0"
 
 require "time"
 require "uri"
 
+require "sensu/json"
 require "sensu/logger"
 require "sensu/settings"
 require "sensu/extensions"
 require "sensu/transport"
 require "sensu/spawn"
+require "sensu/redis"
 
 require "sensu/constants"
 require "sensu/utilities"
 require "sensu/cli"
-require "sensu/redis"
-
-# Symbolize hash keys when parsing JSON.
-MultiJson.load_options = {:symbolize_keys => true}
 
 module Sensu
   module Daemon
@@ -73,10 +72,26 @@ module Sensu
       end
     end
 
+    # Print the Sensu settings and immediately exit the process. This
+    # method is used while troubleshooting configuration issues,
+    # triggered by a CLI argument, e.g. `--print_config`. Sensu
+    # settings with sensitive values (e.g. passwords) are first
+    # redacted.
+    #
+    # @param settings [Object]
+    def print_settings(settings)
+      redacted_settings = redact_sensitive(settings.to_hash)
+      @logger.warn("outputting compiled configuration and exiting")
+      puts Sensu::JSON.dump(redacted_settings, :pretty => true)
+      exit
+    end
+
     # Load Sensu settings and validate them. If there are validation
     # failures, log them (concerns), then cause the Sensu process to
     # exit (2). This method creates the settings instance variable:
-    # `@settings`.
+    # `@settings`. If the `print_config` option is true, this method
+    # calls `print_settings()` to output the compiled configuration
+    # settings and then exit the process.
     #
     # https://github.com/sensu/sensu-settings
     #
@@ -91,6 +106,7 @@ module Sensu
         @logger.fatal("SENSU NOT RUNNING!")
         exit 2
       end
+      print_settings(@settings) if options[:print_config]
     end
 
     # Load Sensu extensions and log any concerns. Set the logger and
@@ -176,6 +192,9 @@ module Sensu
     # method creates the transport instance variable: `@transport`.
     #
     # https://github.com/sensu/sensu-transport
+    #
+    # @yield [Object] passes initialized and connected Transport
+    #   connection object to the callback/block.
     def setup_transport
       transport_name = @settings[:transport][:name]
       transport_settings = @settings[transport_name]
@@ -184,24 +203,27 @@ module Sensu
         :settings => transport_settings
       })
       Transport.logger = @logger
-      @transport = Transport.connect(transport_name, transport_settings)
-      @transport.on_error do |error|
-        @logger.fatal("transport connection error", :error => error.to_s)
-        if @settings[:transport][:reconnect_on_error]
-          @transport.reconnect
-        else
-          stop
+      Transport.connect(transport_name, transport_settings) do |connection|
+        @transport = connection
+        @transport.on_error do |error|
+          @logger.error("transport connection error", :error => error.to_s)
+          if @settings[:transport][:reconnect_on_error]
+            @transport.reconnect
+          else
+            stop
+          end
         end
-      end
-      @transport.before_reconnect do
-        unless testing?
-          @logger.warn("reconnecting to transport")
-          pause
+        @transport.before_reconnect do
+          unless testing?
+            @logger.warn("reconnecting to transport")
+            pause
+          end
         end
-      end
-      @transport.after_reconnect do
-        @logger.info("reconnected to transport")
-        resume
+        @transport.after_reconnect do
+          @logger.info("reconnected to transport")
+          resume
+        end
+        yield(@transport)
       end
     end
 
@@ -210,22 +232,29 @@ module Sensu
     # service will stop gracefully in the event of a Redis error, and
     # pause/resume in the event of connectivity issues. This method
     # creates the Redis instance variable: `@redis`.
+    #
+    # https://github.com/sensu/sensu-redis
+    #
+    # @yield [Object] passes initialized and connected Redis
+    #   connection object to the callback/block.
     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
-        unless testing?
-          @logger.warn("reconnecting to redis")
-          pause
+      Redis.connect(@settings[:redis]) do |connection|
+        @redis = connection
+        @redis.on_error do |error|
+          @logger.error("redis connection error", :error => error.to_s)
         end
-      end
-      @redis.after_reconnect do
-        @logger.info("reconnected to redis")
-        resume
+        @redis.before_reconnect do
+          unless testing?
+            @logger.warn("reconnecting to redis")
+            pause
+          end
+        end
+        @redis.after_reconnect do
+          @logger.info("reconnected to redis")
+          resume
+        end
+        yield(@redis)
       end
     end
 

data/lib/sensu/server/filter.rb

@@ -3,6 +3,8 @@ require "sensu/server/sandbox"
 module Sensu
   module Server
     module Filter
+      EVAL_PREFIX = "eval:".freeze
+
       # 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.
@@ -165,28 +167,63 @@ module Sensu
         end
       end
 
-      # Ruby eval() a string containing an expression, within the
+      # Process a filter eval attribute, a Ruby `eval()` string
+      # containing an expression to be evaluated within the
+      # scope/context of a sandbox. This methods strips away the
+      # expression prefix, `eval:`, and substitues any dot notation
+      # tokens with the corresponding event data values. If there are
+      # unmatched tokens, this method will return `nil`.
+      #
+      # @event [Hash]
+      # @raw_eval_string [String]
+      # @return [String] processed eval string.
+      def process_eval_string(event, raw_eval_string)
+        eval_string = raw_eval_string.slice(5..-1)
+        eval_string, unmatched_tokens = substitute_tokens(eval_string, event)
+        if unmatched_tokens.empty?
+          eval_string
+        else
+          @logger.error("filter eval unmatched tokens", {
+            :raw_eval_string => raw_eval_string,
+            :unmatched_tokens => unmatched_tokens,
+            :event => event
+          })
+          nil
+        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.
+      # attribute value. Dot notation tokens in the expression, e.g.
+      # `:::mysql.user:::`, are substituted with the corresponding
+      # event data values prior to evaluation. The expression is
+      # expected to return a boolean value.
       #
+      # @param event [Hash]
       # @param raw_eval_string [String] containing the Ruby
       #   expression to be evaluated.
-      # @param value [Object] of the corresponding event attribute.
+      # @param raw_value [Object] of the corresponding event
+      #   attribute value.
       # @return [TrueClass, FalseClass]
-      def eval_attribute_value(raw_eval_string, value)
-        begin
-          eval_string = raw_eval_string.gsub(/\Aeval:(\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
-          })
+      def eval_attribute_value(event, raw_eval_string, raw_value)
+        eval_string = process_eval_string(event, raw_eval_string)
+        unless eval_string.nil?
+          begin
+            value = Marshal.load(Marshal.dump(raw_value))
+            !!Sandbox.eval(eval_string, value)
+          rescue => error
+            @logger.error("filter attribute eval error", {
+              :event => event,
+              :raw_eval_string => raw_eval_string,
+              :raw_value => raw_value,
+              :error => error.to_s
+            })
+            false
+          end
+        else
           false
         end
       end
@@ -197,21 +234,23 @@ module Sensu
       # key/value pairs (recursive), have equal string values, or
       # evaluate to true (Ruby eval).
       #
-      # @param hash_one [Hash]
-      # @param hash_two [Hash]
+      # @param event [Hash]
+      # @param filter_attributes [Object]
+      # @param event_attributes [Object]
       # @return [TrueClass, FalseClass]
-      def filter_attributes_match?(hash_one, hash_two)
-        hash_one.all? do |key, value_one|
-          value_two = hash_two[key]
+      def filter_attributes_match?(event, filter_attributes, event_attributes=nil)
+        event_attributes ||= event
+        filter_attributes.all? do |key, value_one|
+          value_two = event_attributes[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
+            filter_attributes_match?(event, value_one, value_two)
+          when value_one.to_s == value_two.to_s
             true
-          when value_one.is_a?(String) && value_one.start_with?("eval:")
-            eval_attribute_value(value_one, value_two)
+          when value_one.is_a?(String) && value_one.start_with?(EVAL_PREFIX)
+            eval_attribute_value(event, value_one, value_two)
           else
             false
           end
@@ -236,7 +275,7 @@ module Sensu
         case
         when @settings.filter_exists?(filter_name)
           filter = @settings[:filters][filter_name]
-          matched = filter_attributes_match?(filter[:attributes], event)
+          matched = filter_attributes_match?(event, filter[:attributes])
           yield(filter[:negate] ? matched : !matched)
         when @extensions.filter_exists?(filter_name)
           extension = @extensions[:filters][filter_name]

data/lib/sensu/server/mutate.rb

@@ -40,7 +40,7 @@ module Sensu
       # @param callback [Proc] to call when the mutator executes
       #   successfully.
       def pipe_mutator(mutator, event, &callback)
-        options = {:data => MultiJson.dump(event), :timeout => mutator[:timeout]}
+        options = {:data => Sensu::JSON.dump(event), :timeout => mutator[:timeout]}
         block = mutator_callback(mutator, event, &callback)
         Spawn.process(mutator[:command], options, &block)
       end

data/lib/sensu/server/process.rb

@@ -43,6 +43,20 @@ module Sensu
         @handling_event_count = 0
       end
 
+      # Set up the Redis and Transport connection objects, `@redis`
+      # and `@transport`. This method "drys" up many instances of
+      # `setup_redis()` and `setup_transport()`.
+      #
+      # @yield callback/block called after connecting to Redis and the
+      #   Sensu Transport.
+      def setup_connections
+        setup_redis do
+          setup_transport do
+            yield
+          end
+        end
+      end
+
       # Create a registration check definition for a client. Client
       # definitions may contain `:registration` configuration,
       # containing custom attributes and handler information. By
@@ -127,10 +141,11 @@ module Sensu
               @redis.set(signature_key, client[:signature])
             end
             if signature.nil? || signature.empty? || (client[:signature] == signature)
-              @redis.set(client_key, MultiJson.dump(client)) do
-                @redis.sadd("clients", client[:name]) do
-                  yield(true) if block_given?
-                end
+              @redis.multi
+              @redis.set(client_key, Sensu::JSON.dump(client))
+              @redis.sadd("clients", client[:name])
+              @redis.exec do
+                yield(true) if block_given?
               end
             else
               @logger.warn("invalid client signature", {
@@ -156,11 +171,11 @@ module Sensu
         @transport.subscribe(:direct, "keepalives", "keepalives", :ack => true) do |message_info, message|
           @logger.debug("received keepalive", :message => message)
           begin
-            client = MultiJson.load(message)
+            client = Sensu::JSON.load(message)
             update_client_registry(client) do
               @transport.ack(message_info)
             end
-          rescue MultiJson::ParseError => error
+          rescue Sensu::JSON::ParseError => error
             @logger.error("failed to parse keepalive payload", {
               :message => message,
               :error => error.to_s
@@ -273,20 +288,18 @@ module Sensu
           :check => check
         })
         result_set = "#{check[:name]}:#{check[:issued]}"
-        result_data = MultiJson.dump(:output => check[:output], :status => check[:status])
-        @redis.hset("aggregation:#{result_set}", client[:name], result_data) do
-          SEVERITIES.each do |severity|
-            @redis.hsetnx("aggregate:#{result_set}", severity, 0)
-          end
-          severity = (SEVERITIES[check[:status]] || "unknown")
-          @redis.hincrby("aggregate:#{result_set}", severity, 1) do
-            @redis.hincrby("aggregate:#{result_set}", "total", 1) do
-              @redis.sadd("aggregates:#{check[:name]}", check[:issued]) do
-                @redis.sadd("aggregates", check[:name])
-              end
-            end
-          end
+        result_data = Sensu::JSON.dump(:output => check[:output], :status => check[:status])
+        @redis.multi
+        @redis.hset("aggregation:#{result_set}", client[:name], result_data)
+        SEVERITIES.each do |severity|
+          @redis.hsetnx("aggregate:#{result_set}", severity, 0)
         end
+        severity = (SEVERITIES[check[:status]] || "unknown")
+        @redis.hincrby("aggregate:#{result_set}", severity, 1)
+        @redis.hincrby("aggregate:#{result_set}", "total", 1)
+        @redis.sadd("aggregates:#{check[:name]}", check[:issued])
+        @redis.sadd("aggregates", check[:name])
+        @redis.exec
       end
 
       # Truncate check output. For metric checks, (`"type":
@@ -301,7 +314,7 @@ module Sensu
         when METRIC_CHECK_TYPE
           output_lines = check[:output].split("\n")
           output = output_lines.first || check[:output]
-          if output_lines.size > 1 || output.length > 255
+          if output_lines.length > 1 || output.length > 255
             output = output[0..255] + "\n..."
           end
           check.merge(:output => output)
@@ -323,15 +336,16 @@ module Sensu
       # stored (history, etc).
       def store_check_result(client, check)
         @logger.debug("storing check result", :check => check)
-        @redis.sadd("result:#{client[:name]}", check[:name])
         result_key = "#{client[:name]}:#{check[:name]}"
+        history_key = "history:#{result_key}"
         check_truncated = truncate_check_output(check)
-        @redis.set("result:#{result_key}", MultiJson.dump(check_truncated)) do
-          history_key = "history:#{result_key}"
-          @redis.rpush(history_key, check[:status]) do
-            @redis.ltrim(history_key, -21, -1)
-            yield
-          end
+        @redis.multi
+        @redis.sadd("result:#{client[:name]}", check[:name])
+        @redis.set("result:#{result_key}", Sensu::JSON.dump(check_truncated))
+        @redis.rpush(history_key, check[:status])
+        @redis.ltrim(history_key, -21, -1)
+        @redis.exec do
+          yield
         end
       end
 
@@ -355,7 +369,7 @@ module Sensu
         history_key = "history:#{client[:name]}:#{check[:name]}"
         @redis.lrange(history_key, -21, -1) do |history|
           total_state_change = 0
-          unless history.size < 21
+          unless history.length < 21
             state_changes = 0
             change_weight = 0.8
             previous_status = history.first
@@ -427,7 +441,7 @@ module Sensu
       # @yieldparam event [Hash]
       def update_event_registry(client, check)
         @redis.hget("events:#{client[:name]}", check[:name]) do |event_json|
-          stored_event = event_json ? MultiJson.load(event_json) : nil
+          stored_event = event_json ? Sensu::JSON.load(event_json) : nil
           flapping = check_flapping?(stored_event, check)
           event = {
             :id => random_uuid,
@@ -441,7 +455,7 @@ module Sensu
             if stored_event && check[:status] == stored_event[:check][:status]
               event[:occurrences] = stored_event[:occurrences] + 1
             end
-            @redis.hset("events:#{client[:name]}", check[:name], MultiJson.dump(event)) do
+            @redis.hset("events:#{client[:name]}", check[:name], Sensu::JSON.dump(event)) do
               yield(event)
             end
           elsif stored_event
@@ -498,7 +512,7 @@ module Sensu
         client_key = result[:check][:source] || result[:client]
         @redis.get("client:#{client_key}") do |client_json|
           unless client_json.nil?
-            client = MultiJson.load(client_json)
+            client = Sensu::JSON.load(client_json)
             if client[:signature]
               if client[:signature] == result[:signature]
                 yield(client)
@@ -563,10 +577,10 @@ module Sensu
         @logger.debug("subscribing to results")
         @transport.subscribe(:direct, "results", "results", :ack => true) do |message_info, message|
           begin
-            result = MultiJson.load(message)
+            result = Sensu::JSON.load(message)
             @logger.debug("received result", :result => result)
             process_check_result(result)
-          rescue MultiJson::ParseError => error
+          rescue Sensu::JSON::ParseError => error
             @logger.error("failed to parse result payload", {
               :message => message,
               :error => error.to_s
@@ -620,7 +634,7 @@ module Sensu
           :subscribers => check[:subscribers]
         })
         check[:subscribers].each do |subscription|
-          options = transport_publish_options(subscription, MultiJson.dump(payload))
+          options = transport_publish_options(subscription, Sensu::JSON.dump(payload))
           @transport.publish(*options) do |info|
             if info[:error]
               @logger.error("failed to publish check request", {
@@ -704,7 +718,7 @@ module Sensu
         @redis.get("client:#{client_name}:signature") do |signature|
           payload[:signature] = signature if signature
           @logger.debug("publishing check result", :payload => payload)
-          @transport.publish(:direct, "results", MultiJson.dump(payload)) do |info|
+          @transport.publish(:direct, "results", Sensu::JSON.dump(payload)) do |info|
             if info[:error]
               @logger.error("failed to publish check result", {
                 :payload => payload,
@@ -758,7 +772,7 @@ module Sensu
           clients.each do |client_name|
             @redis.get("client:#{client_name}") do |client_json|
               unless client_json.nil?
-                client = MultiJson.load(client_json)
+                client = Sensu::JSON.load(client_json)
                 next if client[:keepalives] == false
                 check = create_keepalive_check(client)
                 time_since_last_keepalive = Time.now.to_i - client[:timestamp]
@@ -810,7 +824,7 @@ module Sensu
                 result_key = "#{client_name}:#{check_name}"
                 @redis.get("result:#{result_key}") do |result_json|
                   unless result_json.nil?
-                    check = MultiJson.load(result_json)
+                    check = Sensu::JSON.load(result_json)
                     next unless check[:ttl] && check[:executed] && !check[:force_resolve]
                     time_since_last_execution = Time.now.to_i - check[:executed]
                     if time_since_last_execution >= check[:ttl]
@@ -845,21 +859,21 @@ module Sensu
         @redis.smembers("aggregates") do |checks|
           checks.each do |check_name|
             @redis.smembers("aggregates:#{check_name}") do |aggregates|
-              if aggregates.size > 20
+              if aggregates.length > 20
                 aggregates.sort!
-                aggregates.take(aggregates.size - 20).each do |check_issued|
-                  @redis.srem("aggregates:#{check_name}", check_issued) do
-                    result_set = "#{check_name}:#{check_issued}"
-                    @redis.del("aggregate:#{result_set}") do
-                      @redis.del("aggregation:#{result_set}") do
-                        @logger.debug("pruned aggregation", {
-                          :check => {
-                            :name => check_name,
-                            :issued => check_issued
-                          }
-                        })
-                      end
-                    end
+                aggregates.take(aggregates.length - 20).each do |check_issued|
+                  result_set = "#{check_name}:#{check_issued}"
+                  @redis.multi
+                  @redis.srem("aggregates:#{check_name}", check_issued)
+                  @redis.del("aggregate:#{result_set}")
+                  @redis.del("aggregation:#{result_set}")
+                  @redis.exec do
+                    @logger.debug("pruned aggregation", {
+                      :check => {
+                        :name => check_name,
+                        :issued => check_issued
+                      }
+                    })
                   end
                 end
               end
@@ -1059,9 +1073,9 @@ module Sensu
       # Start the Sensu server process, connecting to Redis, the
       # transport, and calling the `bootstrap()` method.
       def start
-        setup_redis
-        setup_transport
-        bootstrap
+        setup_connections do
+          bootstrap
+        end
       end
 
       # Pause the Sensu server process, unless it is being paused or