kingkong 0.0.3 → 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4bfaec9396fa86c7c0484de4dd88affae2e9c035bb0d852b636c17984ed1cc75
+  data.tar.gz: 65422b13ae9bc35a30142fd6122f1e39ff7bdf6c54540a0883b782df2dba55c7
+SHA512:
+  metadata.gz: f12defa32b00eb145534d1e646fc75ccf4b8c3e2303fb83df711b7c3d93e0a5e42c202d54de491a3b48b85b38e2ef299def35fe3985e2474b05439784ae469d1
+  data.tar.gz: 7b5a3082d15e447ae822880d2b510e43afd52ebd6e236d948848814f4df0cc3230162a4a9008ce8d608136dd6cdd5b893256e7620fccee9fcb6f548651ce252c

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.2-p290

data/Gemfile

@@ -1,17 +1,4 @@
 source "http://rubygems.org"
 
 # Specify your gem's dependencies in kingkong.gemspec
-gemspec
-
-gem 'em-http-request'
-gem 'json'
-
-group :test, :development do
-  gem 'rspec'
-  gem 'guard-rspec'
-  gem 'growl'
-  gem 'rb-fsevent'
-  gem 'em-ventually'
-  gem 'timecop'
-  gem 'ruby-debug19'
-end
+gemspec

data/README.md

@@ -30,27 +30,46 @@
 
 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:
-    
+## Getting Started
+
+Install the KingKong gem.
+
+    gem install kingkong
+
+Then implement your ping checks in Ruby.
+
     require 'kingkong'
     require 'em-http-request'
-    
-    KingKing::Runner.start {
+
+    KingKong.start {
       socket '/tmp/king_kong.socket' # Check this socket with Munin and make a graph!
-      
+
       ping(:google).every(3).seconds do |ping|
-        google = EventMachine::HttpRequest.new('http://google.com/')
+        ping.start
+        google = EventMachine::HttpRequest.new('http://google.com/').get
         google.callback { ping.stop }
-        google.errback { ping.fail }
-        ping.start and google.get
+        google.errback  { ping.fail }
       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!
       end
+
+      ping(:verizon).every(2).seconds do |ping|
+        # Hook your machine up to a GSM serial modem
+        # and perform regular SMS pings against your app.
+      end
     }
 
-and its going to aggregate stats so you can plug it into munin and get all sorts of graphing goodness.
+Save the file and run it! You'll see some crazy log output right now, but eventually its going to be prettier.
+
+You can see the stat aggregates of the pings by looking into the socket:
+
+    watch cat /tmp/king_kong.socket
+
+If you don't understand EventMachine, you might have a little trouble getting this stuff working. Eventually I'd like to hook up Em::Syncrony and a nicer DSL for common tasks, like HTTP checks, to keep things simple.
+
+## Using KingKong with Munin graphs
 
-Stay tuned, I'm still working out the ping DSL and reporting infrastructure!
+I'm working on this!

data/kingkong.gemspec

@@ -11,14 +11,20 @@ Gem::Specification.new do |s|
   s.summary     = %q{Build complex network application health checks with Ruby and EventMachine}
   s.description = %q{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 basic reporting facilities that plug into graphing applications like Munin.}
 
-  s.rubyforge_project = "kingkong"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'growl'
+  s.add_development_dependency 'rb-fsevent'
+  s.add_development_dependency 'em-ventually'
+  s.add_development_dependency 'timecop'
+
   s.add_runtime_dependency "eventmachine"
+  s.add_runtime_dependency "nosey"
+  s.add_runtime_dependency "yajl-ruby"
+  s.add_runtime_dependency "em-http-request"
 end

data/lib/kingkong.rb

@@ -4,17 +4,22 @@ 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'
+  autoload :Processor,  'kingkong/processor'
 
   # Default logger for KingKong.
   def self.logger
     @logger ||= Logger.new($stdout)
   end
 
+  # Want to override the default logger? Its cool, change it up here.
   def self.logger=(logger)
     @logger = logger
   end
+
+  # Shortcut for starting a runner
+  def self.start(*args)
+    Runner.new(*args)
+  end
 end

data/lib/kingkong/ping.rb

@@ -70,7 +70,7 @@ module KingKong
     end
 
     def to_s
-      "Ping(#{id}, :#{status})"
+      "Ping(#{id}, :#{status}#{", #{latency}s" if completed?})"
     end
 
     # Generates ids for pings
@@ -83,6 +83,17 @@ module KingKong
       30 # 30 seconds that is!
     end
 
+    # Bust out a hash so that we can encode it into JSON and make some magic happen.
+    def to_hash
+      {
+        'status' => status,
+        'latency' => latency,
+        'start_time' => (start_time.iso8601 if start_time),
+        'end_time' => (end_time.iso8601 if end_time),
+        'ttl' => ttl
+      }
+    end
+
   private
     # Give us the current time in seconds
     def current_time
@@ -108,7 +119,7 @@ module KingKong
 
   private
     # Spits out a key and run for a result
-    def key(count=count)
+    def key(count=count())
       "#{count}:#{run}"
     end
   end

data/lib/kingkong/pinger.rb

@@ -1,9 +1,14 @@
 require 'eventmachine'
+require 'nosey'
+require 'em-http-request'
+require 'yajl'
+require 'time'
 
 module KingKong
+  # Executes pings within a specificed duration.
   class Pinger
     include Logging
-
+    include EventMachine::Deferrable
     attr_reader :wait
 
     def initialize(wait=5,&block)
@@ -25,27 +30,24 @@ module KingKong
       @timer.cancel if @timer
     end
 
-    # Gather up all the numbers we need for reporting later on
-    def aggregator
-      @aggregatore ||= Aggregator.new
+    # Fire this if when a ping completes
+    def on_ping(&block)
+      @on_ping = block
     end
 
   private
     # Add all of the instrumentation callbacks into the ping so we can aggregate it later
     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
+        logger.debug "Ping #{ping}"
+        @on_ping.call(ping) if @on_ping
       }
-
       ping.errback  {
-        logger.debug "Ping #{ping} error (probably a timeout)"
-        aggregator.process ping
+        logger.debug "Ping #{ping}"
+        @on_ping.call(ping) if @on_ping
       }
-
       # Now pass the ping into the block so we can start/stop it
       @block.call(ping, self)
     end

data/lib/kingkong/processor.rb

@@ -0,0 +1,76 @@
+require 'nosey'
+
+module KingKong
+  module Processor
+    # Base class for processing pings
+    class Base
+      # Enable block configurations
+      def initialize(&block)
+        block.call(self) if block_given?
+        self
+      end
+
+      def process(ping)
+        raise 'Not Implemented'
+      end
+    end
+
+    class Nosey < Base
+      def initialize(host='/tmp/kingkong.socket',port=nil)
+        EventMachine::Nosey::SocketServer.start(nosey.report, host, port)
+      end
+
+      def process(ping,name)
+        nosey.increment "#{name}_ping_count"
+        case ping.status
+        when :timed_out
+          nosey.increment "#{name}_ping_timed_out_count"
+        when :completed
+          nosey.increment "#{name}_ping_completed_count"
+          nosey.avg "#{name}_ping_avg_latency", ping.latency
+          nosey.min "#{name}_ping_min_latency", ping.latency
+          nosey.max "#{name}_ping_max_latency", ping.latency
+        end
+      end
+      
+      def nosey
+        @nosey ||= ::Nosey::Probe::Set.new('pinger')
+      end
+    end
+
+    class Cube < Base
+      include Logging
+
+      attr_accessor :url
+      
+      # TODO use web sockets ...
+      def process(ping, name)
+        http = EM::HttpRequest.new(url).post({
+          :body => Yajl::Encoder.encode([cube_hash(ping, name)]),
+          :head => {'content-type' => 'application/json'}
+        })
+        http.callback{
+          case http.response_header.status
+          when 200..204
+            logger.debug "Successfully reported to Cube at #{url}"
+          else
+            logger.error "Could not report to Cube server: HTTP #{http.response_header.status} : #{http.response}"
+          end
+        }
+        http.errback{
+          logger.error "Could not connect to Cube at #{url}"
+        }
+      end
+
+    private
+    # Bust out a hash that cube will understand as JSON
+      def cube_hash(ping, name)
+        {
+          'type' => name.to_s,
+          'time' => Time.now.iso8601,
+          'data' => ping.to_hash
+        }
+      end
+    end
+  end
+end

data/lib/kingkong/runner.rb

@@ -1,21 +1,32 @@
+require 'nosey'
+
 module KingKong
   # Configure multiple pingers to run
   class Runner
     include Logging
 
     # Array of pingers that we're running
-    def ping(name)
-      pinger_configurations[name]
+    def ping(name, &block)
+      DSL::Pinger.new(&block).completed do |pinger|
+        pinger.on_ping do |ping|
+          process ping, name
+        end
+        pingers << pinger
+      end
+    end
+
+    # We use this method to pass our pings through a processor
+    def process(ping, name)
+      @processor.call(ping,name) if @processor
     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
+    # Configure the processor that we use to report pings
+    def on_pong(&block)
+      @processor = block
     end
 
     # Start all of the pingers given the configurations
     def start
-      start_socket
       start_pingers
     end
 
@@ -45,25 +56,14 @@ module KingKong
     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)
+      @pingers ||= []
     end
 
     def self.ensure_running_reactor(&block)
@@ -92,18 +92,21 @@ module KingKong
         # Configure duration as seconds
         def seconds(&block)
           unitize Unit::Second, &block
+          complete
         end
         alias :second :seconds
 
         # Configure the duration as minutes
         def minutes(&block)
           unitize Unit::Minute, &block
+          complete
         end
         alias :minute :minutes
 
         # Configure the ping duration as hours
         def hours(&block)
           unitize Unit::Hour, &block
+          complete
         end
         alias :hour :hours
 
@@ -117,6 +120,12 @@ module KingKong
           KingKong::Pinger.new(duration, &@block)
         end
 
+        # Callback when we've completed the configuration of this thing.
+        def completed(&block)
+          @completed_blk = block
+          self
+        end
+
       private
         # Figures out the number of seconds that we multply by the units
         def unitize(units, &block)
@@ -124,6 +133,12 @@ module KingKong
           @block = block
           self
         end
+
+        # Yay! Its complete!
+        def complete
+          @completed_blk.call(pinger) if @completed_blk
+          self
+        end
       end
     end
   end

data/lib/kingkong/version.rb

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

data/spec/lib/kingkong/ping_spec.rb

@@ -6,6 +6,10 @@ describe KingKong::Ping do
     KingKong::Ping.new.ttl.should eql(KingKong::Ping.default_ttl)
   end
 
+  it "should return hash" do
+    KingKong::Ping.new.to_hash.keys.should include(*%w[status latency start_time end_time ttl])
+  end
+
   context "active" do
     before(:each) do
       @ping = KingKong::Ping.new      # Open up a pinger

data/spec/lib/kingkong/runner_spec.rb

@@ -8,13 +8,15 @@ describe KingKong::Runner 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
+      runner.ping(:google).every(0.1).seconds do |ping|
+        ping.start
+        ping.stop
         @@google_pinged = true
       end
 
-      runner.ping(:twitter).every(2).seconds do
+      runner.ping(:twitter).every(2).seconds do |ping|
+        ping.start
+        ping.stop
         @@twitter_pinged = true
       end
     end
@@ -26,8 +28,19 @@ describe KingKong::Runner do
   end
 
   it "should write data to socket" do
+    nosey = KingKong::Processor::Nosey.new('/tmp/king_kong_test.socket')
+
+    @runner.on_pong do |ping, name|
+      nosey.process ping, name
+    end
+
     @runner.start
-    # puts UNIXSocket.new('/tmp/king_kong.socket').gets("\n\n")
+    c = KingKong::Test::ReadSocket.start('/tmp/king_kong_test.socket')
+    c.send_data("READ\nQUIT\n")
+    c.callback{|data|
+      @data = data
+    }
+    ly{ @data }.test{|data| data =~ /max/ }
   end
 end
 

data/spec/spec_helper.rb

@@ -8,5 +8,31 @@ RSpec.configure do |config|
   config.mock_framework = :rspec
 end
 
+module KingKong
+  module Test
+    # Read data from a socket and then kill it right away.
+    class ReadSocket < EventMachine::Connection
+      include EventMachine::Deferrable
+
+      def receive_data(data)
+        buffer << data
+      end
+
+      def unbind
+        succeed buffer
+      end
+
+      def self.start(host,port=nil)
+        EventMachine::connect host, port, self
+      end
+
+    private
+      def buffer
+        @buffer ||= ""
+      end
+    end
+  end
+end
+
 # Squelch the logger so we can see our specs passing
 KingKong.logger = Logger.new('/dev/null')

metadata

@@ -1,94 +1,205 @@
 --- !ruby/object:Gem::Specification
 name: kingkong
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 1.0.2
 platform: ruby
 authors:
 - Brad Gessler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-13 00:00:00.000000000 -07:00
-default_executable: 
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-ventually
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70233419803860 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70233419803860
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nosey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 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
   basic reporting facilities that plug into graphing applications like Munin.
 email:
 - brad@bradgessler.com
-executables:
-- kingkong-munin
-- kingkong-server
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rvmrc
+- ".gitignore"
+- ".rbenv-version"
 - Gemfile
 - Guardfile
 - README.md
 - Rakefile
-- bin/kingkong-munin
-- bin/kingkong-server
 - kingkong.gemspec
 - lib/kingkong.rb
-- lib/kingkong/aggregator.rb
 - lib/kingkong/cli.rb
 - lib/kingkong/logging.rb
 - lib/kingkong/ping.rb
 - lib/kingkong/pinger.rb
-- lib/kingkong/reporting.rb
+- lib/kingkong/processor.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: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: kingkong
-rubygems_version: 1.6.2
+rubygems_version: 3.1.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 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
+test_files: []

data/.rvmrc

@@ -1 +0,0 @@
-rvm use --create --install 1.9.2@kingkong

data/bin/kingkong-munin

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'socket'
-require 'yaml'
-
-puts case ARGV.first
- when /config/
-  %(graph_title Result latency
-graph_category App
-graph_vlabel load
-load.label load)  
-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/bin/kingkong-server

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'bundler/setup'
-require 'kingkong'
-
-EventMachine::run do
-  trap('TERM')  { EM.stop }
-  trap('INT')   { EM.stop }
-end

data/lib/kingkong/aggregator.rb

@@ -1,71 +0,0 @@
-module KingKong
-  # Processes and aggregates samples for reporting. These stats will probably
-  # be accessed throug the KingKong::Server UNIX socket.
-  class Aggregator
-    attr_reader :sum, :timed_out_count, :count, :started_at, :min, :max
-
-    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(*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
-
-    # avg latency of samples
-    def avg
-      count.zero? ? 0  : sum / count
-    end
-
-    # 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
-      {
-        '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 start sampling it all again!
-    def reset
-      @sum = 0.0
-      @min = nil
-      @max = nil
-      @count = 0
-      @timed_out_count = 0
-      @samples = Array.new
-      @started_at = Time.now
-    end
-  end
-end

data/lib/kingkong/reporting.rb

@@ -1,37 +0,0 @@
-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/server.rb

@@ -1,24 +0,0 @@
-module KingKong
-  # Opens a UNIX socket to report pinger statistics
-  class Server < EventMachine::Connection
-    Frame = "\r\n"
-
-    def initialize(pinger)
-      @pinger = pinger
-    end
-
-    def post_init
-      send_data frame @pinger.aggregator.to_hash.to_yaml
-    end
-
-    # Start an instance of the aggregator server on a unix port
-    def self.start(pinger, host='/tmp/kingkong.socket', port=nil)
-      EM.start_server host, port, self, pinger
-    end
-
-  private
-    def frame(message)
-      "#{message}#{Frame}"
-    end
-  end
-end

data/spec/lib/kingkong/aggregator_spec.rb

@@ -1,32 +0,0 @@
-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