instrumental_agent 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+Thumbs.db
+Gemfile.lock
+pkg/
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{spec/(spec_helper|test_server).rb})  { "spec/" }
+end

data/README.rdoc

@@ -0,0 +1,35 @@
+= Instrumental Agent
+
+Instrument anything.
+
+== Setup
+
+Add the gem to your Gemfile.
+
+  gem 'instrumental-agent'
+
+Head over to instrumentalapp.com and setup an account, then 
+initialize the agent.
+
+  I = Instrumental::Agent.new('YOUR_API_KEY')
+
+  # or, if you're using eventmachine already
+
+  I = Instrumental::Agent.new('YOUR_API_KEY', :start_reactor => false)
+
+Now you can begin to use instrumental to track your application
+
+  I.gauge('load', 1.23)
+  I.increment('signups')
+
+Data without historical context sucks, so Instrumental lets you 
+backfill data to. Letting you see deep into your past.
+
+  User.find_each do |user|
+    I.increment('signups', 1, user.created_at)
+  end
+
+Running under Rails? You can also give our experimental rack middleware 
+a shot by initializing it with:
+
+    Instrumental::Middleware.boot

data/Rakefile

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

data/bin/watch_server.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'instrumental_agent'
+
+
+class SystemInspector
+  TYPES = [:gauges, :incrementors]
+  attr_accessor *TYPES
+
+  def initialize
+    @gauges = {}
+    @incrementors = {}
+    @platform =
+      case RUBY_PLATFORM
+      when /linux/
+        Linux
+      when /darwin/
+        OSX
+      else
+        raise "unsupported OS"
+      end
+  end
+
+  def load_all
+    load @platform.load_cpu
+    load @platform.load_memory
+    load @platform.load_disks
+  end
+
+  def load(stats)
+    @gauges.merge!(stats[:gauges] || {})
+  end
+
+  module OSX
+    def self.load_cpu
+      { :gauges => top }
+    end
+
+    def self.top
+      lines = []
+      processes = date = load = cpu = nil
+      IO.popen('top -l 1 -n 0') do |top|
+        processes = top.gets.split(': ')[1]
+        date = top.gets
+        load = top.gets.split(': ')[1]
+        cpu = top.gets.split(': ')[1]
+      end
+
+      user, system, idle = cpu.split(", ").map { |v| v.to_f }
+      load1, load5, load15 = load.split(", ").map { |v| v.to_f }
+      total, running, stuck, sleeping, threads = processes.split(", ").map { |v| v.to_i }
+
+      {
+        'cpu.user' => user,
+        'cpu.system' => system,
+        'cpu.idle' => idle,
+        'load.1min' => load1,
+        'load.5min' => load5,
+        'load.15min' => load15,
+        'processes.total' => total,
+        'processes.running' => running,
+        'processes.stuck' => stuck,
+        'processes.sleeping' => sleeping,
+        'threads' => threads,
+      }
+    end
+
+    def self.load_memory
+      # TODO: swap
+      { :gauges => vm_stat }
+    end
+
+    def self.vm_stat
+      header, *rows = `vm_stat`.split("\n")
+      page_size = header.match(/page size of (\d+) bytes/)[1].to_i
+      sections = ["free", "active", "inactive", "wired", "speculative", "wired down"]
+      output = {}
+      total = 0.0
+      rows.each do |row|
+        if match = row.match(/Pages (.*):\s+(\d+)\./)
+          section, value = match[1, 2]
+          if sections.include?(section)
+            value = value.to_f * page_size / 1024 / 1024
+            output["memory.#{section.gsub(' ', '_')}_mb"] = value
+            total += value
+          end
+        end
+      end
+      output["memory.free_percent"] = output["memory.free_mb"] / total * 100 # TODO: verify
+      output
+    end
+
+    def self.load_disks
+      { :gauges => df }
+    end
+
+    def self.df
+      output = {}
+      `df -k`.split("\n").grep(%r{^/dev/}).each do |line|
+        device, total, used, available, capacity, mount = line.split(/\s+/)
+        names = [File.basename(device)]
+        names << 'root' if mount == '/'
+        names.each do |name|
+          output["disk.#{name}.total_mb"] = total.to_f / 1024
+          output["disk.#{name}.used_mb"] = used.to_f / 1024
+          output["disk.#{name}.available_mb"] = available.to_f / 1024
+          output["disk.#{name}.available_percent"] = available.to_f / total.to_f * 100
+        end
+      end
+      output
+    end
+
+    def self.netstat(interface = 'en1')
+      # mostly functional network io stats
+      headers, *lines = `netstat -ibI #{interface}`.split("\n").map { |l| l.split(/\s+/) } # FIXME: vulnerability?
+      headers = headers.map { |h| h.downcase }
+      lines.each do |line|
+        if !line[3].include?(':')
+          return Hash[headers.zip(line)]
+        end
+      end
+    end
+  end
+end
+
+# TODO: swap
+# TODO: utilization
+
+
+token, collector = *ARGV
+unless token
+  puts "Usage: #{$0} <token> [collector]"
+  exit 1
+end
+I = Instrumental::Agent.new(token, :collector => collector)
+
+host = `hostname`.chomp
+
+puts "Collecting stats under the hostname: #{host}"
+
+loop do
+  inspector = SystemInspector.new
+  inspector.load_all
+  inspector.gauges.each do |stat, value|
+    I.gauge("#{host}.#{stat}", value)
+  end
+  # I.increment("#{host}.#{stat}", delta)
+  sleep 1
+end

data/instrumental_agent.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "instrumental/version"
+
+Gem::Specification.new do |s|
+  s.name        = "instrumental_agent"
+  s.version     = Instrumental::VERSION
+  s.authors     = ["Elijah Miller", "Christopher Zelenak"]
+  s.email       = ["elijah.miller@gmail.com", "netshade@gmail.com"]
+  s.homepage    = "http://github.com/fastestforward/instrumental_agent"
+  s.summary     = %q{Agent for reporting data to instrumentalapp.com}
+  s.description = %q{Keep track of anything.}
+
+  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"]
+
+  s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+  s.add_development_dependency(%q<rspec>, ["~> 2.0"])
+  s.add_development_dependency(%q<guard>, [">= 0"])
+  s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+  s.add_development_dependency(%q<growl_notify>, [">= 0"])
+  s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
+end

data/lib/instrumental/agent.rb

@@ -0,0 +1,170 @@
+require 'instrumental/setup'
+require 'instrumental/version'
+require 'eventmachine'
+require 'logger'
+
+# Sets up a connection to the collector.
+#
+#  Instrumental::Agent.new(API_KEY)
+module Instrumental
+  class Agent
+    attr_accessor :host, :port
+    attr_reader :connection
+    
+    def self.start_reactor
+      unless EM.reactor_running?
+        logger.debug 'Starting EventMachine reactor'
+        Thread.new { EM.run }
+      end
+    end
+
+    def self.logger=(l)
+      @logger = l
+    end
+
+    def self.logger
+      @logger ||= Logger.new('/dev/null')
+    end
+
+    def self.all
+      @agents ||= []
+    end
+
+    def self.new(*args)
+      inst = super
+      all << inst
+      inst
+    end
+
+    module ServerConnection
+      BACKOFF = 2
+      MAX_RECONNECT_DELAY = 5
+      MAX_BUFFER = 10
+
+      attr_accessor :agent
+      attr_reader :connected, :failures, :buffer
+
+      def initialize(agent, api_key)
+        @agent = agent
+        @buffer = []
+        @api_key = api_key
+      end
+
+      def logger
+        agent.logger
+      end
+
+      def connection_completed
+        logger.info "connected to collector"
+        @connected = true
+        @failures = 0
+        send_data("hello version #{Instrumental::VERSION}\n")
+        send_data("authenticate #{@api_key}\n") if @api_key
+        dropped = @buffer.dup
+        @buffer = []
+        dropped.each do |msg|
+          send_data(msg)
+        end
+      end
+
+      def receive_data(data)
+        logger.debug "Received: #{data.chomp}"
+      end
+
+      def send_data(data)
+        if @connected
+          super
+        else
+          if @buffer.size < MAX_BUFFER
+            @buffer << data
+          end
+        end
+      end
+
+      def unbind
+        @connected = false
+        @failures = @failures.to_i + 1
+        delay = [@failures ** BACKOFF / 10.to_f, MAX_RECONNECT_DELAY].min
+        logger.info "disconnected, reconnect in #{delay}..."
+        EM::Timer.new(delay) do
+          reconnect(agent.host, agent.port)
+        end
+      end
+
+    end
+
+    # Sets up a connection to the collector.
+    #
+    #  Instrumental::Agent.new(API_KEY)
+    #  Instrumental::Agent.new(API_KEY, :collector => 'hostname:port')
+    def initialize(api_key, options = {})
+      default_options = { :start_reactor => true }
+      options = default_options.merge(options)
+      @api_key = api_key
+      if options[:collector]
+        @host, @port = options[:collector].split(':')
+        @port = (@port || 8000).to_i
+      else
+        @host = 'instrumentalapp.com'
+        @port = 8000
+      end
+
+      self.class.start_reactor if options[:start_reactor]
+
+      EM.next_tick do
+        @connection = EM.connect host, port, ServerConnection, self, api_key
+      end
+    end
+
+    # Store a gauge for a metric, optionally at a specific time.
+    #
+    #  agent.gauge('load', 1.23)
+    def gauge(metric, value, time = Time.now)
+      if valid?(metric, value, time)
+        send_command("gauge", metric, value, time.to_i)
+      end
+    end
+
+    # Increment a metric, optionally more than one or at a specific time.
+    #
+    #  agent.increment('users')
+    def increment(metric, value = 1, time = Time.now)
+      valid?(metric, value, time)
+      send_command("increment", metric, value, time.to_i)
+    end
+
+    def connected?
+      connection && connection.connected
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    private
+
+    def valid?(metric, value, time)
+      if metric !~ /^([\d\w\-_]+\.)*[\d\w\-_]+$/i
+        increment 'agent.invalid_metric'
+        logger.warn "Invalid metric #{metric}"
+        return false
+      end
+      if value.to_s !~ /^\d+(\.\d+)?$/
+        increment 'agent.invalid_value'
+        logger.warn "Invalid value #{value.inspect} for #{metric}"
+        return false
+      end
+      true
+    end
+
+    def send_command(cmd, *args)
+      cmd = "%s %s\n" % [cmd, args.collect(&:to_s).join(" ")]
+      logger.debug "Sending: #{cmd.chomp}"
+      EM.next_tick do
+        connection.send_data(cmd)
+      end
+    end
+
+
+  end
+end

data/lib/instrumental/rack/middleware.rb

@@ -0,0 +1,85 @@
+module Instrumental
+  class Middleware
+    def self.boot
+      if @stack = detect_stack
+        @stack.install_middleware
+        @enabled = true
+      else
+        @enabled = false
+      end
+    end
+
+    def self.stack; @stack; end
+
+    def self.enabled; @enabled; end
+    def self.enabled=(v); @enabled = v; end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def stack
+      Middleware.stack
+    end
+
+    def measure(env, &block)
+      response = nil
+      if Middleware.enabled
+        request = Rack::Request.new(env)
+        key_parts = stack.recognize_uri(request)
+        if key = key_parts.join(".")
+          exc = nil
+          tms = Benchmark.measure do
+            begin
+              response = yield
+            rescue Exception => e
+              exc = e
+            end
+          end
+          begin
+            Agent.all.each do |agent|
+              if exc
+                agent.increment("%s.error.%s" % [key, exc.class])
+              end
+              if response && response.first
+                agent.increment("%s.status.%i" % [key, response.first])
+              else
+                agent.increment(key)
+              end
+            end
+          rescue Exception => e
+            stack.log "Error occurred sending stats: #{e}"
+            stack.log e.backtrace.join("\n")
+          end
+          raise exc if exc
+        end
+      end
+      response ||= yield
+    end
+
+    def call(env)
+      measure(env) do
+        @app.call(env)
+      end
+    end
+
+    class Stack
+      def self.default_logger
+        @logger ||= Logger.new('/dev/null')
+      end
+
+      def log(msg)
+        Stack.default_logger.error(msg)
+      end
+    end
+
+    private
+
+    def self.detect_stack
+      [Rails3, Rails23].collect { |klass| klass.create }.detect { |obj| !obj.nil? }
+    end
+  end
+end
+
+require 'instrumental/rack/rails3'
+require 'instrumental/rack/rails23'

data/lib/instrumental/rack/rails23.rb

@@ -0,0 +1,27 @@
+module Instrumental
+  class Middleware
+    class Rails23 < Stack
+      def self.create
+        if (defined?(::RAILS_VERSION) && const_get(:RAILS_VERSION).to_s =~ /^2\.3/) ||
+            (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_s =~ /^2\.3/)
+          new
+        end
+      end
+
+      def install_middleware
+        Rails.configuration.middleware.use Instrumental::Middleware
+      end
+
+      def log(msg)
+        Rails.logger.error msg
+      end
+
+      def recognize_uri(request)
+        params = ActionController::Routing::Routes.recognize_path(request.path, request.env.merge(:method => request.env["REQUEST_METHOD"].downcase.to_sym))
+        ["controller", params[:controller], params[:action]]
+      rescue ActionController::RoutingError => e
+        ["controller", "unknown"]
+      end
+    end
+  end
+end

data/lib/instrumental/rack/rails3.rb

@@ -0,0 +1,27 @@
+module Instrumental
+  class Middleware
+    class Rails3 < Stack
+      def self.create
+        if defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_s =~ /^3/
+          new
+        end
+      end
+
+      def install_middleware
+        require 'instrumental/rack/rails3/middleware_bootstrap'
+      end
+
+      def log(msg)
+        Rails.logger.error msg
+      end
+
+      def recognize_uri(request)
+        Rails.application.routes.finalize!
+        params = Rails.application.routes.recognize_path(request.url, request.env)
+        ["controller", params[:controller], params[:action]]
+      rescue ActionController::RoutingError => e
+        ["controller", "unknown"]
+      end
+    end
+  end
+end

data/lib/instrumental/rack/rails3/middleware_bootstrap.rb

@@ -0,0 +1,6 @@
+module Instrumental
+  class MiddlewareBootstrap < Rails::Railtie
+    config.app_middleware.use Instrumental::Middleware
+
+  end
+end

data/lib/instrumental/setup.rb

@@ -0,0 +1,3 @@
+require 'instrumental/rack/middleware'
+
+Instrumental::Middleware.boot

data/lib/instrumental/version.rb

@@ -0,0 +1,4 @@
+module Instrumental
+  VERSION = "0.1.0"
+end
+  

data/lib/instrumental_agent.rb

@@ -0,0 +1 @@
+require 'instrumental/agent'

data/spec/agent_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Instrumental::Agent do
+  before do
+    random_port = Time.now.to_i % rand(2000)
+    base_port = 4000
+    @port = base_port + random_port
+    TestServer.start(@port)
+  end
+
+  after do
+    TestServer.stop
+  end
+
+  subject { Instrumental::Agent.new('test_token', :collector => "127.0.0.1:#{@port}") }
+
+  it 'should announce itself including version' do
+    subject.gauge('gauge_test', 123)
+    EM.next do
+      TestServer.last.buffer.first.should match(/hello.*version/)
+    end
+  end
+
+  it 'should authenticate using the token' do
+    subject.gauge('gauge_test', 123)
+    EM.next do
+      TestServer.last.buffer[1].should == "authenticate test_token"
+    end
+  end
+
+  it 'should report a gauge to the collector' do
+    now = Time.now
+    subject.gauge('gauge_test', 123)
+    EM.next do
+      TestServer.last.buffer.last.should == "gauge gauge_test 123 #{now.to_i}"
+    end
+  end
+
+  it 'should report a gauge to the collector with a set time' do
+    subject.gauge('gauge_test', 123, 555)
+    EM.next do
+      TestServer.last.buffer.last.should == 'gauge gauge_test 123 555'
+    end
+  end
+
+  it "should automatically reconnect" do
+    EM.next do
+      subject.gauge('gauge_test', 123, 555)
+    end
+    EM.next do
+      subject.connection.close_connection(false)
+    end
+    EM.next do
+      subject.gauge('gauge_test', 444, 555)
+    end
+    EM.next do
+      TestServer.last.buffer.last.should == 'gauge gauge_test 444 555'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'instrumental_agent'
+require 'test_server'
+
+RSpec.configure do |config|
+
+  config.before(:all) do
+    unless EM.reactor_running?
+      EM.error_handler { |*args| 
+        puts "\n"
+        puts "*" * 80
+        puts "EVENTMACHINE ERROR: #{args.inspect}\n" 
+        puts args.first.backtrace.join("\n")
+        puts "*" * 80
+        puts "\n"
+      }
+      Thread.new { EM.run }
+      sleep(0.001) while !EM.reactor_running?
+    end
+  end
+
+  config.after(:all) do
+    EM.stop
+  end
+
+end
+
+
+module EM
+
+  def self.next(&block)
+    EM.wait_for_events
+    mtx = Mutex.new
+    exc = nil
+    EM.next_tick do
+      mtx.synchronize {
+        begin
+          yield
+        rescue Exception => e
+          exc = e
+        end
+      }
+    end
+    EM.wait_for_events
+    mtx.lock
+    raise exc if exc
+    true
+  end
+
+  def self.wait_for_events
+    raise "Reactor is not running" unless EM.reactor_running?
+    while EM.reactor_running? && !(@next_tick_queue && @next_tick_queue.empty? && @timers && @timers.empty?)
+      sleep(0.01) # This value is REALLY important
+                  # Too low and it doesn't allow 
+                  # local socket events to finish 
+                  # processing
+                  # Too high and it makes the tests 
+                  # slow.  
+    end
+    raise @wrapped_exception if @wrapped_exception
+  end
+end

data/spec/test_server.rb

@@ -0,0 +1,85 @@
+module TestServer
+  CMUTEX = Mutex.new
+
+  def self.start_reactor
+    Thread.new { EM.run } unless EM.reactor_running?
+  end
+
+  def self.start(port)
+    start_reactor
+    unless @sig
+      EM.next_tick {
+        @sig = EventMachine.start_server "127.0.0.1", port, TestServer
+      }
+    end
+  end
+
+  def self.stop
+    if (sig=@sig)
+      EM.next_tick {
+        EventMachine.stop_server sig
+      }
+      @sig = nil
+    end
+  end
+
+  def self.connections
+    CMUTEX.synchronize do 
+      @connections ||= []
+      @connections.dup
+    end
+  end
+
+  def self.add_connection(conn)
+    CMUTEX.synchronize do
+      @connections ||= []
+      @connections << conn
+    end
+  end
+
+  def self.remove_connection(conn)
+    CMUTEX.synchronize do
+      @connections ||= []
+      @connections.delete(conn)
+    end
+  end
+
+  def self.last
+    connections.last
+  end
+
+  def post_init
+    TestServer.add_connection(self)
+  end
+
+  def receive_data data
+    buffer_response(data)
+  end
+
+  def unbind
+    TestServer.remove_connection(self)
+  end
+
+  def last_message
+    buffer.last
+  end
+
+  def buffer
+    @buffer ||= []
+    @buffer.dup
+  end
+
+  def clear_buffer!
+    @buffer = []
+  end
+
+  def buffer_response(dt)
+    @buffer ||= []
+    dt.split(/\n/).each do |measurement|
+      @buffer << measurement
+    end
+    dt
+  end
+end
+
+

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification 
+name: instrumental_agent
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Elijah Miller
+- Christopher Zelenak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-27 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: growl_notify
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Keep track of anything.
+email: 
+- elijah.miller@gmail.com
+- netshade@gmail.com
+executables: 
+- watch_server.rb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Guardfile
+- README.rdoc
+- Rakefile
+- bin/watch_server.rb
+- instrumental_agent.gemspec
+- lib/instrumental/agent.rb
+- lib/instrumental/rack/middleware.rb
+- lib/instrumental/rack/rails23.rb
+- lib/instrumental/rack/rails3.rb
+- lib/instrumental/rack/rails3/middleware_bootstrap.rb
+- lib/instrumental/setup.rb
+- lib/instrumental/version.rb
+- lib/instrumental_agent.rb
+- spec/agent_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb
+has_rdoc: true
+homepage: http://github.com/fastestforward/instrumental_agent
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: Agent for reporting data to instrumentalapp.com
+test_files: 
+- spec/agent_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb