kingkong 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+bin/polleverywhere

data/.rvmrc

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

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in kingkong.gemspec
+gemspec
+
+gem 'em-http-request'
+gem 'json'

data/README.md

@@ -0,0 +1,33 @@
+# KingKong
+
+                ,.-" "-.,
+               /   ===   \
+              /  =======  \
+           __|  (o)   (0)  |__      
+          / _|    .---.    |_ \         
+         | /.----/ O O \----.\ |       
+          \/     |     |     \/        
+          |                   |            
+          |                   |           
+          |                   |          
+          _\   -.,_____,.-   /_         
+      ,.-"  "-.,_________,.-"  "-.,
+     /          |       |          \  
+    |           l.     .l           | 
+    |            |     |            |
+    l.           |     |           .l             
+     |           l.   .l           | \,     
+     l.           |   |           .l   \,    
+      |           |   |           |      \,  
+      l.          |   |          .l        |
+       |          |   |          |         |
+       |          |---|          |         |
+       |          |   |          |         |
+       /"-.,__,.-"\   /"-.,__,.-"\"-.,_,.-"\
+      |            \ /            |         |
+      |             |             |         |
+       \__|__|__|__/ \__|__|__|__/ \_|__|__/ KingKong gets what KingKong wants!
+
+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.
+
+Stay tuned, I'm still working out the ping DSL and reporting infrastructure!

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/kingkong-munin

@@ -0,0 +1,15 @@
+#!/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

data/bin/kingkong-server

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

data/kingkong.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "kingkong/version"
+
+Gem::Specification.new do |s|
+  s.name        = "kingkong"
+  s.version     = KingKong::VERSION
+  s.authors     = ["Brad Gessler"]
+  s.email       = ["brad@bradgessler.com"]
+  s.homepage    = ""
+  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_runtime_dependency "eventmachine"
+end

data/lib/README.md

@@ -0,0 +1,33 @@
+# KingKong
+
+                ,.-" "-.,
+               /   ===   \
+              /  =======  \
+           __|  (o)   (0)  |__      
+          / _|    .---.    |_ \         
+         | /.----/ O O \----.\ |       
+          \/     |     |     \/        
+          |                   |            
+          |                   |           KingKong gets what KingKong wants!
+          |                   |          
+          _\   -.,_____,.-   /_         
+      ,.-"  "-.,_________,.-"  "-.,
+     /          |       |          \  
+    |           l.     .l           | 
+    |            |     |            |
+    l.           |     |           .l             
+     |           l.   .l           | \,     
+     l.           |   |           .l   \,    
+      |           |   |           |      \,  
+      l.          |   |          .l        |
+       |          |   |          |         |
+       |          |---|          |         |
+       |          |   |          |         |
+       /"-.,__,.-"\   /"-.,__,.-"\"-.,_,.-"\
+      |            \ /            |         |
+      |             |             |         |
+       \__|__|__|__/ \__|__|__|__/ \_|__|__/
+
+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.
+
+Stay tuned, I'm still working out the ping DSL and reporting infrastructure!

data/lib/kingkong.rb

@@ -0,0 +1,8 @@
+require "kingkong/version"
+
+module KingKong
+  autoload :Ping,       'kingkong/ping'
+  autoload :Server,     'kingkong/server'
+  autoload :Logging,    'kingkong/logging'
+  autoload :Aggregator, 'kingkong/aggregator'
+end

data/lib/kingkong/aggregator.rb

@@ -0,0 +1,56 @@
+module KingKong
+  # Processes and aggregates pings for reporting. These stats will probably
+  # be accessed throug the KingKong::Server UNIX socket.
+  class Aggregator
+    attr_reader :sum, :max_count, :pings, :started_at
+
+    def initialize(max_count=10)
+      @max_count = max_count
+      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
+      end
+    end
+
+    # Average latency of pings
+    def avg
+      count.zero? ? 0  : sum / count
+    end
+
+    # Number of pings
+    def count
+      pings.size
+    end
+
+    # Basic statistical summary of ping latency
+    def to_hash
+      {
+        :avg => avg,
+        :count => count,
+        :sum => sum,
+        :started_at => started_at
+      }
+    end
+
+    def to_s
+      to_hash.to_yaml
+    end
+
+    # Reset all of the counts to 0 and empty all of the pings
+    def reset
+      @sum        = 0
+      @pings      = Array.new
+      @started_at = Time.now
+    end
+  end
+end

data/lib/kingkong/cli.rb

@@ -0,0 +1,4 @@
+module KingKong
+  class CLI < Thor
+  end
+end

data/lib/kingkong/logging.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+module KingKong
+  # Logging concern for each class
+  module Logging
+    def logger
+      KingKong.logger
+    end
+  end
+
+  # Default logger for KingKong.
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+end

data/lib/kingkong/ping.rb

@@ -0,0 +1,102 @@
+require 'eventmachine'
+
+module KingKong
+  # Encaspulates and calculates latency.
+  class Ping
+    attr_accessor :end_time, :ttl
+
+    def initialize(ttl=30,sequencer=self.class.sequencer)
+      # Time out is when the ping should give up!
+      @ttl, @sequencer = ttl, sequencer
+    end
+
+    # Lazily grab a id
+    def id
+      @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
+    end
+
+    # Set the end time
+    def pong
+      @end_time ||= current_time
+    end
+
+    # How long did it take to clear the message?
+    def latency
+      end_time - start_time if end_time
+    end
+
+    # Did this get ponged yet?
+    def completed?
+      !!end_time
+    end
+
+    # Is this ping still on its journy? Will it make it back! It hasn't yet...
+    def active?
+      !timed_out? or !completed?
+    end
+
+    # Did we not receive a pong?
+    def timed_out?
+      start_time + ttl < current_time and not end_time
+    end
+
+    # Give us the current time in seconds
+    def current_time
+      Time.now.to_f
+    end
+
+    # Generates ids for pings
+    def self.sequencer
+      @sequencer ||= Sequencer.new
+    end
+  end
+
+  # Keeps track of the results heading in/out. We could just use 
+  # some totally random GUID instead of bothering with this, but 
+  # having a 1,2,3... sequence makes it much easier to spot check
+  # tests to verify whether or not messages are being sent correctly.
+  class Ping::Sequencer
+    attr_reader :count, :run
+
+    def initialize(run=Time.now.to_i)
+      @run, @count = run, 0
+    end
+
+    # Tick up the restul count and give us the key
+    def next
+      key @count += 1
+    end
+    
+  private
+    # Spits out a key and run for a result
+    def key(count=count)
+      "#{count}:#{run}"
+    end
+  end
+
+  # Add evented functionality to a ping so that it times out, etc.
+  class Ping::Deferrable < Ping
+    include EventMachine::Deferrable
+    
+    # Setup a ttl for the ping so that it will timeout after ttl seconds
+    def start_time
+      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)
+      callback(&block) if block_given?
+      super
+      succeed self
+    end
+  end
+end

data/lib/kingkong/server.rb

@@ -0,0 +1,24 @@
+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/lib/kingkong/version.rb

@@ -0,0 +1,3 @@
+module KingKong
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: kingkong
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brad Gessler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70132736057580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70132736057580
+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
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- bin/kingkong-munin
+- bin/kingkong-server
+- kingkong.gemspec
+- lib/README.md
+- lib/kingkong.rb
+- lib/kingkong/aggregator.rb
+- lib/kingkong/cli.rb
+- lib/kingkong/logging.rb
+- lib/kingkong/ping.rb
+- lib/kingkong/server.rb
+- lib/kingkong/version.rb
+homepage: ''
+licenses: []
+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.8.6
+signing_key: 
+specification_version: 3
+summary: Build complex network application health checks with Ruby and EventMachine
+test_files: []