kingkong 0.0.2 → 0.0.3

data/Gemfile

@@ -12,4 +12,6 @@ group :test, :development do
   gem 'growl'
   gem 'rb-fsevent'
   gem 'em-ventually'
+  gem 'timecop'
+  gem 'ruby-debug19'
 end

data/Guardfile

@@ -1,4 +1,4 @@
-guard 'rspec', :cli => '--color --format nested', :version => 2 do
+guard 'rspec', :cli => '--color --format nested --debug', :version => 2 do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec/" }

data/README.md

@@ -8,8 +8,8 @@
          | /.----/ O O \----.\ |       
           \/     |     |     \/        
           |                   |            
-          |                   |           KingKong gets what KingKong wants!
-          |                   |          
+          |                   |       Full stack health checks for your networked apps!
+          |                   |         (Kinda like Pingdom, but way deeper and free)
           _\   -.,_____,.-   /_         
       ,.-"  "-.,_________,.-"  "-.,
      /          |       |          \  
@@ -28,26 +28,23 @@
       |             |             |         |
        \__|__|__|__/ \__|__|__|__/ \_|__|__/
 
-KingKong makes it easy to build full-stack ping-pong checks. You might need this to check and graph out the response time on your website, Twitter application, SMS gateway, or whatever else you'd connect to a network.
+KingKong makes it easy to build full-stack ping-pong health checks so you can keep an eye on crucial input/outputs and make sure things stay nice and fast. You might need this to check and graph out the response time on your website, Twitter application, SMS gateway, or whatever else you'd connect to a network.
 
 When its done, it will look something like this:
-
-    KingKing.monitor {
-      socket '/tmp/kingkong.socket' # Munin can check this for stats
-
+    
+    require 'kingkong'
+    require 'em-http-request'
+    
+    KingKing::Runner.start {
+      socket '/tmp/king_kong.socket' # Check this socket with Munin and make a graph!
+      
       ping(:google).every(3).seconds do |ping|
-        google = http('http://www.google.com/').get
-
-        ping.on_timeout {
-          # ZOMG! Email the admin! Google is down!
-        }
-
-        ping.start_time           # Start the clock!
-        google.callback {         # This triggers the request
-          ping.end_time           # And this stops the clock!
-        }
+        google = EventMachine::HttpRequest.new('http://google.com/')
+        google.callback { ping.stop }
+        google.errback { ping.fail }
+        ping.start and google.get
       end
-
+      
       ping(:twitter).every(10).seconds do |ping|
         # Wire up your own thing in here that tweets
         # .. and when you pick that up, end the pong!

data/bin/kingkong-munin

@@ -4,7 +4,7 @@ require 'socket'
 require 'yaml'
 
 puts case ARGV.first
-when /config/
+ when /config/
   %(graph_title Result latency
 graph_category App
 graph_vlabel load
@@ -13,3 +13,6 @@ else
   stats = YAML.load UNIXSocket.new("/tmp/kingkong.socket").gets("\r\n")
   %(load.value #{stats[:avg]})
 end
+
+# TODO - Message throughput
+# TODO - Message latency (min/max/avg)

data/lib/kingkong.rb

@@ -3,9 +3,11 @@ require "kingkong/version"
 module KingKong
   autoload :Ping,       'kingkong/ping'
   autoload :Pinger,     'kingkong/pinger'
+  autoload :Runner,     'kingkong/runner'
   autoload :Server,     'kingkong/server'
   autoload :Logging,    'kingkong/logging'
   autoload :Aggregator, 'kingkong/aggregator'
+  autoload :Reporting,  'kingkong/reporting'
 
   # Default logger for KingKong.
   def self.logger

data/lib/kingkong/aggregator.rb

@@ -1,55 +1,70 @@
 module KingKong
-  # Processes and aggregates pings for reporting. These stats will probably
+  # Processes and aggregates samples for reporting. These stats will probably
   # be accessed throug the KingKong::Server UNIX socket.
   class Aggregator
-    attr_reader :sum, :max_count, :pings, :started_at
+    attr_reader :sum, :timed_out_count, :count, :started_at, :min, :max
 
-    def initialize(max_count=10_000)
-      @max_count = max_count
+    def initialize
       reset
     end
 
     # Accept a ping message, keep a running total, and make sure we stay within the
     # size of the number of samples that we want to keep around.
-    def process(ping)
-      @sum+=ping.latency
-      pings.push ping
-
-      # Take out the old ping if we're approaching our max sample size and substruct it
-      # from the running latency sum
-      if count > max_count and ping = pings.shift
-        @sum-=ping.latency
+    def process(*pings)
+      pings.each do |ping|
+        @count+=1
+        case ping.status
+        when :timed_out
+          @timed_out_count+=1
+        else
+          # This happens on our first ping before we have a min/max
+          @min = @max = ping.latency if @min.nil? and @max.nil?
+          # Cool! Lets do some math
+          @min = ping.latency if ping.latency < @min
+          @max = ping.latency if ping.latency > @max
+          # We need to sum latency to calculate avgs
+          @sum += ping.latency
+        end
       end
     end
 
-    # Average latency of pings
+    # avg latency of samples
     def avg
       count.zero? ? 0  : sum / count
     end
 
-    # Number of pings
-    def count
-      pings.size
+    # What percentage of requests are timed out?
+    def timed_out_percentage
+      timed_out_count > 0 ? timed_out_count / count : 0
     end
 
     # Basic statistical summary of ping latency
     def to_hash
       {
-        :avg => avg,
-        :count => count,
-        :sum => sum,
-        :started_at => started_at
+        'started_at' => started_at,
+        'avg' => avg,
+        'sum' => sum,
+        'min' => min,
+        'max' => max,
+        'count' => count,
+        'timed_out_count' => timed_out_count,
+        'successful_count' => count - timed_out_count
       }
     end
 
+    # Print out a string for this that is suitable for flushing out to a socket
     def to_s
       to_hash.to_yaml
     end
 
-    # Reset all of the counts to 0 and empty all of the pings
+    # Reset all of the counts to 0 and start sampling it all again!
     def reset
-      @sum        = 0.0
-      @pings      = Array.new
+      @sum = 0.0
+      @min = nil
+      @max = nil
+      @count = 0
+      @timed_out_count = 0
+      @samples = Array.new
       @started_at = Time.now
     end
   end

data/lib/kingkong/ping.rb

@@ -3,9 +3,11 @@ require 'eventmachine'
 module KingKong
   # Encaspulates and calculates latency.
   class Ping
-    attr_accessor :end_time, :ttl
+    NotStartedError= Class.new(RuntimeError)
 
-    def initialize(ttl=30,sequencer=self.class.sequencer)
+    attr_accessor :end_time, :start_time, :ttl
+
+    def initialize(ttl=self.class.default_ttl,sequencer=self.class.sequencer)
       # Time out is when the ping should give up!
       @ttl, @sequencer = ttl, sequencer
     end
@@ -15,48 +17,77 @@ module KingKong
       @id ||= @sequencer.next
     end
 
-    # When did the ping start? This is also what starts the time for this thing
-    def start_time
-      unless @start_time
-        @start_time = current_time
-      end
-      @start_time
+    # Start the ping and set a start time
+    def start
+      @start_time ||= current_time
     end
+    alias :ping :start
 
-    # Set the end time
-    def pong
+    # Stop the ping and set a stop time
+    def stop
+      raise Ping::NotStartedError.new("The ping must be started to stop") unless @start_time
+      # We have a start time? Cool! Lets stop this thing then
       @end_time ||= current_time
     end
+    alias :pong :stop
 
     # How long did it take to clear the message?
     def latency
-      end_time - start_time if end_time
+      end_time.to_f - start_time.to_f if end_time
+    end
+
+    # Figure out the state of this ping.
+    def status
+      if !end_time and !start_time
+        :not_started
+      elsif start_time and !end_time and start_time + ttl < current_time
+        :timed_out
+      elsif start_time and !end_time
+        :active
+      elsif start_time and end_time
+        :completed
+      end
     end
 
     # Did this get ponged yet?
     def completed?
-      !!end_time
+      status == :completed
     end
 
     # Is this ping still on its journy? Will it make it back! It hasn't yet...
     def active?
-      !timed_out? or !completed?
+      status == :active
     end
 
     # Did we not receive a pong?
     def timed_out?
-      start_time + ttl < current_time and not end_time
+      status == :timed_out
     end
 
-    # Give us the current time in seconds
-    def current_time
-      Time.now.to_f
+    # Nothing happened ye
+    def not_started?
+      status == :not_started
+    end
+
+    def to_s
+      "Ping(#{id}, :#{status})"
     end
 
     # Generates ids for pings
     def self.sequencer
       @sequencer ||= Sequencer.new
     end
+
+    # Default TTL. Override this method if you want a different default.
+    def self.default_ttl
+      30 # 30 seconds that is!
+    end
+
+  private
+    # Give us the current time in seconds
+    def current_time
+      Time.now
+    end
   end
 
   # Keeps track of the results heading in/out. We could just use 
@@ -74,7 +105,7 @@ module KingKong
     def next
       key @count += 1
     end
-    
+
   private
     # Spits out a key and run for a result
     def key(count=count)
@@ -87,13 +118,13 @@ module KingKong
     include EventMachine::Deferrable
     
     # Setup a ttl for the ping so that it will timeout after ttl seconds
-    def start_time
+    def start
       timeout(ttl) # Setup an em TTL on this thing so it fails if the thing isn't called
       super
     end
 
     # Succeed a block passed into the ping and mark the ping as suceeded
-    def pong(&block)
+    def stop(&block)
       callback(&block) if block_given?
       super
       succeed self

data/lib/kingkong/pinger.rb

@@ -4,17 +4,19 @@ module KingKong
   class Pinger
     include Logging
 
-    attr_accessor :aggregator, :duration
+    attr_reader :wait
 
-    def initialize(duration=5)
-      @duration = duration
+    def initialize(wait=5,&block)
+      @wait = wait
+      @block = block if block_given?
+      self
     end
 
     # Starts the pinger
-    def start(&block)
+    def start
       logger.debug "Starting pinger #{self}"
-      @timer = EventMachine::PeriodicTimer.new(duration){ ping(&block) }
-      ping(&block)
+      @timer = EventMachine::PeriodicTimer.new(wait){ ping }
+      ping # Start a ping right away, the timer above will fire later.
     end
 
     # Stop the pinger from executing
@@ -27,22 +29,25 @@ module KingKong
     def aggregator
       @aggregatore ||= Aggregator.new
     end
-    
+
   private
     # Add all of the instrumentation callbacks into the ping so we can aggregate it later
-    def ping(&block)
-      ping = Ping::Deferrable.new(30, sequencer)
+    def ping
+      ping = Ping::Deferrable.new(Ping.default_ttl, sequencer)
+
       # Register the aggregator to process the ping
       ping.callback { 
         logger.debug "Ping #{ping} successful"
         aggregator.process ping
       }
+
       ping.errback  {
         logger.debug "Ping #{ping} error (probably a timeout)"
         aggregator.process ping
       }
+
       # Now pass the ping into the block so we can start/stop it
-      yield ping if block_given?
+      @block.call(ping, self)
     end
 
     # Setup a squencer that's unique specifically to this pinger

data/lib/kingkong/reporting.rb

@@ -0,0 +1,37 @@
+require 'eventmachine'
+
+module KingKong
+  # Provides access to the pinger via a Socket or TCP port so that other
+  # services, like Munin for example, can graph the data.
+  module Reporting
+    class Server < EventMachine::Connection
+      Terminator = "\n\n"
+      Host = '/tmp/king_kong.socket'
+      Port = nil
+
+      attr_accessor :aggregators
+
+      # Accept a collection of aggregators that we'll use to report our stats.
+      def initialize(*aggregators)
+        @aggregators = aggregators
+      end
+
+      # Dump out the stats and close down the connection
+      def post_init
+        begin
+          send_data "#{aggregators.each(&:to_s).join("\n")}#{Terminator}"
+        rescue => e
+          send_data "Exception! #{e}\n#{e.backtrace}"
+        ensure
+          close_connection
+        end
+      end
+
+      # A nice short-cut for peeps who aren't familar with EM to fire up
+      # an Reporting server with an array of aggregators, host, and a port.
+      def self.start(aggregators, host=Socket::Host, port=Socket::Port)
+        EventMachine::start_server(host, port, self, aggregators)
+      end
+    end
+  end
+end

data/lib/kingkong/runner.rb

@@ -0,0 +1,130 @@
+module KingKong
+  # Configure multiple pingers to run
+  class Runner
+    include Logging
+
+    # Array of pingers that we're running
+    def ping(name)
+      pinger_configurations[name]
+    end
+
+    # Setup the socket that this thing will write stats out to
+    def socket(host=KingKong::Reporting::Server::Host, port=KingKong::Reporting::Server::Port)
+      @socket_host , @socket_port = host, port
+    end
+
+    # Start all of the pingers given the configurations
+    def start
+      start_socket
+      start_pingers
+    end
+
+    # Stop all of the pingers
+    def stop
+      pingers.each(&:stop)      
+    end
+
+    # Open up the configuration DSL for this puppy
+    def configure(&block)
+      block.arity > 1 ? block.call(self) : instance_eval(&block)
+      self
+    end
+
+    # Shortcut for creating a new class and configuring it
+    def self.configure(&block)
+      new.configure(&block)
+    end
+
+    # Shortcut for configuring and starting a KingKong runner
+    def self.run(&block)
+      ensure_running_reactor { 
+        runner = configure(&block)
+        runner.start
+      }
+      runner # For chaining
+    end
+
+  private
+    # Fire up the reporting server if a socket (and port, optionally) are given
+    def start_socket
+      Reporting::Server.start(pingers.map(&:aggregator), @socket_host, @socket_port) if @socket_host
+    end
+
+    # Fire up all the pingers
+    def start_pingers
+      pingers.each(&:start)
+    end
+
+    # Hang onto pinger configuration so that we can configure pinger instances and fire them
+    # off. We'll also be using this for writing reports.
+    def pinger_configurations
+      @pinger_configurations ||= Hash.new{|hash,val| hash[val] = DSL::Pinger.new }
+    end
+
+    # Create instances of pingers from the configurations that we setup in the runner
+    def pingers
+      @pingers ||= pinger_configurations.values.map(&:pinger)
+    end
+
+    def self.ensure_running_reactor(&block)
+      EM.reactor_running? ? block.call : EM.run(&block)
+    end
+  end
+
+  class Runner
+    module DSL
+      # Encapsulate the configuration of a bunch of pingers that we can run in one KingKong file
+      class Pinger
+        # Time units expressed in seconds
+        module Unit
+          Second  = 1
+          Minute  = 60
+          Hour    = 60 * 60
+        end
+
+        attr_accessor :block
+
+        def every(quantity)
+          @quantity = quantity
+          self
+        end
+
+        # Configure duration as seconds
+        def seconds(&block)
+          unitize Unit::Second, &block
+        end
+        alias :second :seconds
+
+        # Configure the duration as minutes
+        def minutes(&block)
+          unitize Unit::Minute, &block
+        end
+        alias :minute :minutes
+
+        # Configure the ping duration as hours
+        def hours(&block)
+          unitize Unit::Hour, &block
+        end
+        alias :hour :hours
+
+        # The number of seconds the timer will wait between ticks. We'll pass this into EM
+        def duration
+          @units * @quantity
+        end
+
+        # Return a configured instance of a pinger that we can fire up and do stuff with
+        def pinger
+          KingKong::Pinger.new(duration, &@block)
+        end
+
+      private
+        # Figures out the number of seconds that we multply by the units
+        def unitize(units, &block)
+          @units = units
+          @block = block
+          self
+        end
+      end
+    end
+  end
+end

data/lib/kingkong/version.rb

@@ -1,3 +1,3 @@
 module KingKong
-  VERSION = "0.0.2"
-end
+  VERSION = "0.0.3"
+end

data/spec/lib/kingkong/aggregator_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require "rspec/mocks/standalone"
+
+describe KingKong::Aggregator do
+  before(:all) do
+    @agg = KingKong::Aggregator.new
+
+    @pings = (1..3).map do |n|
+      ping = KingKong::Ping.new
+      ping.stub(:latency){ n.to_f }
+      ping
+    end
+
+    @agg.process *@pings
+  end
+
+  it "should calculate avg" do
+    @agg.avg.should eql(2.0)
+  end
+
+  it "should calculate sum" do
+    @agg.sum.should eql(6.0)
+  end
+
+  it "should calculate max" do
+    @agg.max.should eql(3.0)
+  end
+
+  it "should calculate min" do
+    @agg.min.should eql(1.0)
+  end
+end

data/spec/lib/kingkong/ping_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'timecop'
+
+describe KingKong::Ping do
+  it "should have default 30 second ttl" do
+    KingKong::Ping.new.ttl.should eql(KingKong::Ping.default_ttl)
+  end
+
+  context "active" do
+    before(:each) do
+      @ping = KingKong::Ping.new      # Open up a pinger
+      Timecop.freeze(@now = Time.now) # Freeze time
+    end
+
+    after(:each) do
+      Timecop.return # Turn Timecop off
+    end
+
+    it "should start" do
+      @ping.start.should eql(@now)
+    end
+
+    it "should be active" do
+      @ping.start
+      @ping.should be_active
+    end
+
+    it "should not be timed out" do
+      @ping.start
+      @ping.should_not be_timed_out
+    end
+
+    it "should not be completed" do
+      @ping.start
+      @ping.should_not be_completed
+    end
+
+    it "should raise exception if stopped but not started" do
+      lambda{
+        @ping.stop
+      }.should raise_exception(KingKong::Ping::NotStartedError)
+    end
+  end
+
+  context "timed out" do
+    before(:all) do
+      @ping = KingKong::Ping.new
+      @span = KingKong::Ping.default_ttl + 1
+
+      Timecop.freeze(@now = Time.now)       # Freeze now
+      @ping.start                           # Start the ping
+      Timecop.freeze(@then = @now + @span)  # Move to a timed-out state, and freeze again
+    end
+
+    after(:all) do
+      Timecop.return # Turn Timecop off
+    end
+
+    it "should not have end time" do
+      @ping.end_time.should be_nil
+    end
+
+    it "should be timed out" do
+      @ping.should be_timed_out
+    end
+
+    it "should not be active" do
+      @ping.should_not be_active
+    end
+
+    it "should not be completed" do
+      @ping.should_not be_completed
+    end
+  end
+
+  context "success" do
+    before(:all) do
+      @ping = KingKong::Ping.new
+      @span = KingKong::Ping.default_ttl - 1 # 1 under the timeout
+
+      Timecop.freeze(@now = Time.now)         # Freeze time
+      @ping.start                             # Start the ping
+      Timecop.freeze(@then = @now + @span)    # Move forward into time whene the ping is successful
+      @ping.stop                              # End the ping
+    end
+
+    after(:all) do
+      Timecop.return # Turn Timecop off
+    end
+
+    it "should stop" do
+      @ping.stop.should eql(@then)
+    end
+
+    it "should have end time" do
+      @ping.end_time.should eql(@then)
+    end
+
+    it "should calculate latency" do
+      @ping.latency.should eql(@then - @now)
+    end
+
+    it "should not be active" do
+      @ping.should_not be_active
+    end
+
+    it "should be completed" do
+      @ping.should be_completed
+    end
+  end
+end
+
+describe KingKong::Ping::Deferrable do
+  include EM::Ventually
+
+  it "should time out" do
+    @ping = KingKong::Ping::Deferrable.new(0.1)
+    @ping.start
+    @ping.errback{ @err_status = :timed_out }
+    ly(:timed_out){ @err_status }
+  end
+
+  it "should callback with a ping if successful" do
+    @ping = KingKong::Ping::Deferrable.new
+    @ping.start
+    @ping.stop
+    @ping.callback{ |ping| @response = ping }
+    ly{ KingKong::Ping }.test{|type| @response.kind_of? type }
+  end
+end
+
+describe KingKong::Ping::Sequencer do
+  before(:all) do
+    @sequencer = KingKong::Ping::Sequencer.new(0)
+  end
+
+  it "should sequence" do
+    count, run = @sequencer.next.split(':')
+    count.should eql("1")
+    run.should eql("0")
+  end
+end

data/spec/lib/kingkong/pinger_spec.rb

@@ -1,19 +1,29 @@
 require 'spec_helper'
 
 describe KingKong::Pinger do
-    include EM::Ventually
+  include EM::Ventually
 
-    before(:all) do
-      @pinger = KingKong::Pinger.new
+  before(:all) do
+    @@pinged = false
+    @pinger = KingKong::Pinger.new(0.1) do |ping, pinger|
+      @@ping = ping
+      ping.start
+      ping.stop
+      pinger.stop
     end
+  end
 
-    it "should start pinging" do
-      @pinger.start
-    end
+  it "should ping" do
+    @pinger.start
+    ly(:completed) { @@ping.status }
+  end
 
-    it "should stop pinging" do
-      @pinger.stop
-    end
+  it "should stop"
+  it "should start"
 
-    it "should sequence pings"
+  context "ping aggregation" do
+    it "should process timed-out"
+    it "should process successful"
+    it "should process errors"
+  end
 end

data/spec/lib/kingkong/runner_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'socket'
+
+describe KingKong::Runner do
+  include EM::Ventually
+
+  before(:each) do
+    @@google_pinged = @@twitter_pinged = false
+
+    @runner = KingKong::Runner.configure do |runner|
+      runner.socket '/tmp/king_kong.socket'
+
+      runner.ping(:google).every(0.1).seconds do
+        @@google_pinged = true
+      end
+
+      runner.ping(:twitter).every(2).seconds do
+        @@twitter_pinged = true
+      end
+    end
+  end
+
+  it "should start pinging" do
+    @runner.start
+    ly(true) { @@google_pinged }
+  end
+
+  it "should write data to socket" do
+    @runner.start
+    # puts UNIXSocket.new('/tmp/king_kong.socket').gets("\n\n")
+  end
+end
+
+describe KingKong::Runner::DSL::Pinger do
+  # Lets kinda simulate this in our DSL
+  def ping(name)
+    KingKong::Runner::DSL::Pinger.new
+  end
+
+  it "should accept minutes" do
+    config = ping(:google).every(3).minutes
+    config.duration.should eql(3 * 60)
+  end
+
+  it "should accept seconds" do
+    config = ping(:google).every(3).seconds
+    config.duration.should eql(3)
+  end
+
+  it "should accept hours" do
+    config = ping(:google).every(3).hours
+    config.duration.should eql(3 * 60 * 60)
+  end
+
+  it "should accept block" do
+    block = Proc.new {}
+    config = ping(:twitter).every(1).second &block
+    config.block.should eql(block)
+  end
+
+  context "pinger configuration" do
+    before(:each) do
+      @pinger = ping(:brad).every(2).hours.pinger
+    end
+    
+    it "should have wait" do
+      @pinger.wait.should eql(2 * KingKong::Runner::DSL::Pinger::Unit::Hour) # 2 hours
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,5 +4,9 @@ require 'eventmachine'
 require 'logger'
 require 'em-ventually'
 
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+end
+
 # Squelch the logger so we can see our specs passing
 KingKong.logger = Logger.new('/dev/null')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kingkong
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-06 00:00:00.000000000Z
+date: 2011-09-13 00:00:00.000000000 -07:00
+default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70207424167020 !ruby/object:Gem::Requirement
+  requirement: &70233419803860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +22,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70207424167020
+  version_requirements: *70233419803860
 description: Have you ever wanted to shoot a message throught Twitter, have your app
   pick it up, do some work on it, and report how long it takes? KingKong makes it
   slightly easier to do this with a DSL for writing custom pings and by providing
@@ -49,11 +50,17 @@ files:
 - lib/kingkong/logging.rb
 - lib/kingkong/ping.rb
 - lib/kingkong/pinger.rb
+- lib/kingkong/reporting.rb
+- lib/kingkong/runner.rb
 - lib/kingkong/server.rb
 - lib/kingkong/version.rb
+- spec/lib/kingkong/aggregator_spec.rb
+- spec/lib/kingkong/ping_spec.rb
 - spec/lib/kingkong/pinger_spec.rb
+- spec/lib/kingkong/runner_spec.rb
 - spec/lib/kingkong_spec.rb
 - spec/spec_helper.rb
+has_rdoc: true
 homepage: ''
 licenses: []
 post_install_message: 
@@ -74,11 +81,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: kingkong
-rubygems_version: 1.8.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Build complex network application health checks with Ruby and EventMachine
 test_files:
+- spec/lib/kingkong/aggregator_spec.rb
+- spec/lib/kingkong/ping_spec.rb
 - spec/lib/kingkong/pinger_spec.rb
+- spec/lib/kingkong/runner_spec.rb
 - spec/lib/kingkong_spec.rb
 - spec/spec_helper.rb