pirate_metrics_agent 0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--colour --format Fuubar

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.1 [October 29, 2012]
+* Initial Version
+* Based on Instrumental Agent 75c4b8c461972ebfa3e792b92c1fdf8d6f630b83

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+gemspec
+gem 'faraday', '~> 0.8.4'
+
+if RUBY_VERSION < "1.9"
+  # Built and installed via ext/mkrf_conf.rb
+  gem 'system_timer', '~> 1.2'
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2, :cli => '--format Fuubar' 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/LICENSE

@@ -0,0 +1,21 @@
+Initial software Copyright (c) 2011 Fastest Forward
+Pirate Metrics portions Copyright (c) 2012 Expected Behavior
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# Pirate Metrics Agent
+
+Get to know your customers
+
+## Setup & Usage
+
+Add the gem to your Gemfile.
+
+```sh
+gem 'pirate_metrics_agent'
+```
+
+Visit [piratemetrics.com](https://piratemetrics.com) and create an account, then  initialize the agent with your API key, found on the main project page.
+
+```sh
+PM = PirateMetrics::Agent.new('YOUR_API_KEY', :enabled => Rails.env.production?)
+```
+
+You'll  probably want something like the above, only enabling the agent in production mode so you don't have development and production data writing to the same value. Or you can setup two projects, so that you can verify stats in one, and release them to production in another.
+
+Now you can begin to use Pirate Metrics to track your application.
+
+```sh
+PM.acquisition({ :email => 'joe@example.com'})    # new user acquisition
+```
+
+**Note**: For your app's safety, the agent is meant to isolate your app from any problems our service might suffer. If it is unable to connect to the service, it will discard data after reaching a low memory threshold.
+
+## Backfilling
+
+You almost certainly have events that occurred before you signed up for Pirate Metrics.  To get all of your users into the proper context, Pirate Metrics allows you to backfill data.
+
+When backfilling, you may send tens of thousands of metrics per second, and the command buffer may start discarding data it isn't able to send fast enough. Using the ! form of the various API calls will force them to be synchronous.
+
+**Warning**: You should only use synchronous mode for backfilling data as any issues with the Pirate Metrics service issues will cause this code to halt until it can reconnect.
+
+```sh
+acquisition_data = []
+User.find_in_batches(:batch_size => 100) do |users|
+  users.each do |user|
+    acquisition_data << {:email => user.email, :occurred_at => user.created_at}
+  end
+  PM.acquisition!(acquisition_data)
+  acquisition_data.clear                        
+end
+```
+## Agent Control
+
+Need to quickly disable the agent? set :enabled to false on initialization and you don't need to change any application code.
+
+## Tracking metrics in Resque jobs (and Resque-like scenarios)
+
+If you plan on tracking metrics in Resque jobs, you will need to explicitly cleanup after the agent when the jobs are finished.  You can accomplish this by adding `after_perform` and `on_failure` hooks to your Resque jobs.  See the Resque [hooks documentation](https://github.com/defunkt/resque/blob/master/docs/HOOKS.md) for more information.
+
+You're required to do this because Resque calls `exit!` when a worker has finished processing, which bypasses Ruby's `at_exit` hooks.  The Pirate Metrics Agent installs an `at_exit` hook to flush any pending metrics to the servers, but this hook is bypassed by the `exit!` call; any other code you rely that uses `exit!` should call `PM.cleanup` to ensure any pending metrics are correctly sent to the server before exiting the process.
+
+## Troubleshooting & Help
+
+We are here to help. Email us at [support@piratemetrics.com](mailto:support@piratemetrics.com).

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rspec_opts = ['--color --backtrace']
+end

data/lib/pirate_metrics/agent.rb

@@ -0,0 +1,266 @@
+require 'pirate_metrics/version'
+require 'pirate_metrics/system_timer'
+require 'faraday'
+require 'logger'
+require 'thread'
+require 'socket'
+
+
+module PirateMetrics
+  class Agent
+    BACKOFF = 2.0
+    MAX_RECONNECT_DELAY = 15
+    MAX_BUFFER = 5000
+    REPLY_TIMEOUT = 10
+    CONNECT_TIMEOUT = 20
+    EXIT_FLUSH_TIMEOUT = 5
+
+    attr_accessor :host, :port, :synchronous, :queue
+    attr_reader :connection, :enabled
+
+    def self.logger=(l)
+      @logger = l
+    end
+
+    def self.logger
+      if !@logger
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::WARN
+      end
+      @logger
+    end
+
+    # Sets up a connection to the collector.
+    #
+    #  PirateMetrics::Agent.new(API_KEY)
+    #  PirateMetrics::Agent.new(API_KEY, :collector => 'hostname:port')
+    def initialize(api_key, options = {})
+      # symbolize options keys
+      options.replace(
+        options.inject({}) { |m, (k, v)| m[(k.to_sym rescue k) || k] = v; m }
+      )
+
+      # defaults
+      # host:        piratemetrics.com
+      # port:        80
+      # enabled:     true
+      # synchronous: false
+      @api_key         = api_key
+      @host, @port     = options[:collector].to_s.split(':')
+      @host            = options[:host] || 'https://piratemetrics.com'
+      @port            = (options[:port] || 443).to_i
+      @enabled         = options.has_key?(:enabled) ? !!options[:enabled] : true
+      @synchronous     = !!options[:synchronous]
+      @pid             = Process.pid
+      @allow_reconnect = true
+
+      setup_cleanup_at_exit if @enabled
+    end
+
+    # Store a customer metric
+    #
+    #  agent.acquisition!({ :email => 'test@example.com',
+    #                       :occurred_at => user.created_at,
+    #                       :level => 'Double Uranium'})
+    [:acquisition, :activation, :retention, :revenue, :referral].each do |metric|
+      define_method metric do |customer|
+        begin
+          payload = customer.is_a?(Array) ? customer : [customer]
+          send_metric(metric, payload, @synchronous)
+        rescue Exception => ex
+          report_exception ex
+          return nil
+        end
+      end
+      define_method "#{metric}!" do |customer|
+        begin
+          payload = customer.is_a?(Array) ? customer : [customer]
+          send_metric(metric, payload, true)
+        rescue Exception => ex
+          report_exception ex
+          return nil
+        end
+      end
+    end
+
+    # Synchronously flush all pending metrics out to the server
+    # By default will not try to reconnect to the server if a
+    # connection failure happens during the flush, though you
+    # may optionally override this behavior by passing true.
+    #
+    #  agent.flush
+    def flush(allow_reconnect = false)
+      queue_metric('flush', nil, {
+        :synchronous => true,
+        :allow_reconnect => allow_reconnect
+      }) if running?
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger || self.class.logger
+    end
+
+    # Stopping the agent will immediately stop all communication
+    # to PirateMetrics.  If you call this and submit another metric,
+    # the agent will start again.
+    #
+    # Calling stop will cause all metrics waiting to be sent to be
+    # discarded.  Don't call it unless you are expecting this behavior.
+    #
+    # agent.stop
+    #
+    def stop
+      if @thread
+        @thread.kill
+        @thread = nil
+      end
+    end
+
+    # Called when a process is exiting to give it some extra time to
+    # push events to the service. An at_exit handler is automatically
+    # registered for this method, but can be called manually in cases
+    # where at_exit is bypassed like Resque workers.
+    def cleanup
+      if running?
+        logger.info "Cleaning up agent, queue size: #{@queue.size}, thread running: #{@thread.alive?}"
+        @allow_reconnect = false
+        if @queue.size > 0
+          queue_metric('exit')
+          begin
+            with_timeout(EXIT_FLUSH_TIMEOUT) { @thread.join }
+          rescue Timeout::Error
+            if @queue.size > 0
+              logger.error "Timed out working agent thread on exit, dropping #{@queue.size} metrics"
+            else
+              logger.error "Timed out PirateMetrics Agent, exiting"
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def with_timeout(time, &block)
+      PirateMetricsTimeout.timeout(time) { yield }
+    end
+
+    def report_exception(e)
+      logger.error "Exception occurred: #{e.message}\n#{e.backtrace.join("\n")}"
+    end
+
+    def send_metric(metric, payload, synchronous = false)
+      if enabled?
+        start_connection_worker if !running?
+        if @queue.size < MAX_BUFFER
+          @queue_full_warning = false
+          logger.debug "Queueing: #{metric} -> #{payload.inspect}"
+          queue_metric(metric, payload, { :synchronous => synchronous })
+        else
+          if !@queue_full_warning
+            @queue_full_warning = true
+            logger.warn "Queue full(#{@queue.size}), dropping commands..."
+          end
+          logger.debug "Dropping command, queue full(#{@queue.size}): #{metric}"
+          nil
+        end
+      end
+    end
+
+    def queue_metric(metric, payload = nil, options = {})
+      if @enabled
+        options ||= {}
+        if options[:allow_reconnect].nil?
+          options[:allow_reconnect] = @allow_reconnect
+        end
+        synchronous = options.delete(:synchronous)
+        if synchronous
+          options[:sync_resource] ||= ConditionVariable.new
+          @sync_mutex.synchronize {
+            @queue << [metric, payload, options]
+            options[:sync_resource].wait(@sync_mutex)
+          }
+        else
+          @queue << [metric, payload, options]
+        end
+      end
+      metric
+    end
+
+    def start_connection_worker
+      if enabled?
+        @pid = Process.pid
+        @queue = Queue.new
+        @sync_mutex = Mutex.new
+        @failures = 0
+        logger.info "Starting thread"
+        @thread = Thread.new do
+          run_worker_loop
+        end
+      end
+    end
+
+    def run_worker_loop
+      command_and_args = nil
+      command_options = nil
+      @piratemetrics = Faraday.new(:url => "#{@host}:#{@port}") do |faraday|
+        faraday.request  :url_encoded
+        faraday.adapter  Faraday.default_adapter
+      end
+      logger.info "connected to collector at #{host}:#{port}"
+      @failures = 0
+      loop do
+        begin
+          metric, payload, options = @queue.pop
+          sync_resource = options && options[:sync_resource]
+          case metric
+          when 'exit'
+            logger.info "Exiting, #{@queue.size} commands remain"
+            return true
+          when 'flush'
+            release_resource = true
+          else
+            logger.debug "Sending: #{metric} -> #{payload.inspect}"
+            result = @piratemetrics.post("/api/v1/#{metric}s", { :api_key => @api_key, :data => payload})
+          end
+          metric = payload = options = nil
+        rescue Exception => err
+          queue_metric(metric, payload, options) if metric
+          sleep MAX_RECONNECT_DELAY
+        end
+        if sync_resource
+          @sync_mutex.synchronize do
+            sync_resource.signal
+          end
+        end
+      end
+    rescue Exception => err
+        if err.is_a?(EOFError)
+          # nop
+      elsif err.is_a?(Errno::ECONNREFUSED)
+        logger.error "unable to connect to PirateMetrics."
+      else
+        report_exception(err)
+      end
+    end
+
+    def setup_cleanup_at_exit
+      at_exit do
+        cleanup
+      end
+    end
+
+    def running?
+      !@thread.nil? && @pid == Process.pid
+    end
+
+  end
+end

data/lib/pirate_metrics/system_timer.rb

@@ -0,0 +1,31 @@
+if RUBY_VERSION < "1.9" && RUBY_PLATFORM != "java"
+  timeout_lib = nil
+  ["SystemTimer", "system_timer"].each do |lib|
+    begin
+      unless timeout_lib
+        gem lib
+        require "system_timer"
+        timeout_lib  = SystemTimer
+      end
+    rescue Exception => e
+    end
+  end
+  if !timeout_lib
+    puts <<-EOMSG
+WARNING:: You do not currently have system_timer installed.
+It is strongly advised that you install this gem when using
+pirate_metrics_agent with Ruby 1.8.x.  You can install it in
+your Gemfile via:
+gem 'system_timer'
+or manually via:
+gem install system_timer
+    EOMSG
+    require 'timeout'
+    PirateMetricsTimeout = Timeout
+  else
+    PirateMetricsTimeout = timeout_lib
+  end
+else
+  require 'timeout'
+  PirateMetricsTimeout = Timeout
+end

data/lib/pirate_metrics/version.rb

@@ -0,0 +1,3 @@
+module PirateMetrics
+  VERSION = '0.1'
+end

data/lib/pirate_metrics_agent.rb

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

data/pirate_metrics_agent.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "pirate_metrics/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pirate_metrics_agent"
+  s.version     = PirateMetrics::VERSION
+  s.authors     = ["Elijah Miller", "Christopher Zelenak", "Kristopher Chambers", "Matthew Hassfurder", "Expected Behavior"]
+  s.email       = ["support@piratemetrics.com"]
+  s.homepage    = "http://github.com/expectedbehavior/pirate_metrics_agent"
+  s.summary     = %q{Agent for reporting data to piratemetrics.com}
+  s.description = %q{Get to know your customers.}
+
+  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_development_dependency(%q<rake>, [">= 0"])
+  s.add_development_dependency(%q<rack>, [">= 0"])
+  s.add_development_dependency(%q<rspec>, ["~> 2.0"])
+  s.add_development_dependency(%q<fuubar>, [">= 0"])
+  if RUBY_VERSION >= "1.8.7"
+    s.add_development_dependency(%q<pry>, ["~> 0.9"])
+    s.add_development_dependency(%q<guard>, [">= 0"])
+    s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+    s.add_development_dependency(%q<growl>, [">= 0"])
+    s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
+  end
+end

data/spec/agent_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+
+def wait
+  sleep 0.1 # FIXME: hack
+end
+
+PirateMetrics::Agent.logger.level = Logger::FATAL
+describe PirateMetrics::Agent, "disabled" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent(:enabled => false)
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should not connect to the server after receiving a metric" do
+    wait
+    @agent.acquisition({:email => 'test@example.com'})
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should no op on flush without reconnect" do
+    1.upto(100) { |i| @agent.acquisition({:email => "test#{i}@example.com"}) }
+    @agent.flush(false)
+    wait
+    @server.metrics.should be_empty
+  end
+
+  it "should no op on flush with reconnect" do
+    1.upto(100) { |i| @agent.acquisition({:email => "test#{i}@example.com"}) }
+    @agent.flush(true)
+    wait
+    @server.metrics.should be_empty
+  end
+
+  it "should no op on an empty flush" do
+    @agent.flush(true)
+    wait
+    @server.metrics.should be_empty
+  end
+end
+
+describe PirateMetrics::Agent, "enabled" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should send an api key" do
+    @agent.acquisition({:email => "test@example.com"})
+    wait
+    @server.last_api_key == "test_token"
+  end
+end
+
+describe PirateMetrics::Agent, "acquisitions" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should report an acquisition using the hash form" do
+    @agent.acquisition({:email => "test@example.com"})
+    wait
+    @server.acquisitions.last.should == { "email" => "test@example.com"}
+  end
+
+  it "should report an acquisition using the array form" do
+    @agent.acquisition([{:email => "test1@example.com"}, { :email => "test2@example.com"}])
+    wait
+    @server.acquisitions.first.should == { "email" => "test1@example.com"}
+    @server.acquisitions.last.should == { "email" => "test2@example.com"}
+  end
+
+  it "should be able to report acquisitions synchronously" do
+    @agent.acquisition!({:email => "test@example.com"})
+    wait
+    @server.acquisitions.last.should == { "email" => "test@example.com"}
+  end
+end
+
+describe PirateMetrics::Agent, "activations" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should report an activation using the hash form" do
+    @agent.activation({:email => "test@example.com"})
+    wait
+    @server.activations.last.should == { "email" => "test@example.com"}
+  end
+
+  it "should report an activation using the array form" do
+    @agent.activation([{:email => "test1@example.com"}, { :email => "test2@example.com"}])
+    wait
+    @server.activations.first.should == { "email" => "test1@example.com"}
+    @server.activations.last.should == { "email" => "test2@example.com"}
+  end
+
+  it "should be able to report activations synchronously" do
+    @agent.activation!({:email => "test@example.com"})
+    wait
+    @server.activations.last.should == { "email" => "test@example.com"}
+  end
+end
+
+describe PirateMetrics::Agent, "retentions" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should report an retention using the hash form" do
+    @agent.retention({:email => "test@example.com"})
+    wait
+    @server.retentions.last.should == { "email" => "test@example.com"}
+  end
+
+  it "should report an retention using the array form" do
+    @agent.retention([{:email => "test1@example.com"}, { :email => "test2@example.com"}])
+    wait
+    @server.retentions.first.should == { "email" => "test1@example.com"}
+    @server.retentions.last.should == { "email" => "test2@example.com"}
+  end
+
+  it "should be able to report retentions synchronously" do
+    @agent.retention!({:email => "test@example.com"})
+    wait
+    @server.retentions.last.should == { "email" => "test@example.com"}
+  end
+end
+
+describe PirateMetrics::Agent, "revenues" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should report an revenue using the hash form" do
+    @agent.revenue({:email => "test@example.com", :amount_in_cents => "1000"})
+    wait
+    @server.revenues.last.should == { "email" => "test@example.com", "amount_in_cents" => "1000"}
+  end
+
+  it "should report an revenue using the array form" do
+    @agent.revenue([{:email => "test1@example.com", :amount_in_cents => "1000"}, { :email => "test2@example.com", :amount_in_cents => "2000"}])
+    wait
+    @server.revenues.first.should == { "email" => "test1@example.com", "amount_in_cents" => "1000"}
+    @server.revenues.last.should == { "email" => "test2@example.com", "amount_in_cents" => "2000"}
+  end
+
+  it "should be able to report revenues synchronously" do
+    @agent.revenue!({:email => "test@example.com", :amount_in_cents => "1000"})
+    wait
+    @server.revenues.last.should == { "email" => "test@example.com", "amount_in_cents" => "1000"}
+  end
+end
+
+
+describe PirateMetrics::Agent, "referrals" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should not connect to the server" do
+    wait
+    @server.connect_count.should == 0
+  end
+
+  it "should report an referral using the hash form" do
+    @agent.referral({:customer_email => "test@example.com", :referree_email => "ref@example.com"})
+    wait
+    @server.referrals.last.should == { "customer_email" => "test@example.com", "referree_email" => "ref@example.com"}
+  end
+
+  it "should report an referral using the array form" do
+    @agent.referral([{:customer_email => "test1@example.com", :referree_email => "ref@example.com"}, { :customer_email => "test2@example.com", :referree_email => "ref2@example.com"}])
+    wait
+    @server.referrals.first.should == { "customer_email" => "test1@example.com", "referree_email" => "ref@example.com"}
+    @server.referrals.last.should == { "customer_email" => "test2@example.com", "referree_email" => "ref2@example.com"}
+  end
+
+  it "should be able to report referrals synchronously" do
+    @agent.referral!({:customer_email => "test@example.com", :referree_email => "ref@example.com"})
+    wait
+    @server.referrals.last.should == { "customer_email" => "test@example.com", "referree_email" => "ref@example.com"}
+  end
+end
+
+describe PirateMetrics::Agent, "agent queueing, synchronicity, reliability" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+  end
+
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
+
+  it "should discard data that overflows the buffer" do
+    with_constants('PirateMetrics::Agent::MAX_BUFFER' => 3) do
+      5.times do |i|
+        @agent.acquisition({ :email => "test#{i}@example.com"})
+      end
+      wait
+      @server.acquisitions.should include({ "email" => "test0@example.com"})
+      @server.acquisitions.should include({ "email" => "test1@example.com"})
+      @server.acquisitions.should include({ "email" => "test2@example.com"})
+      @server.acquisitions.should_not include({ "email" => "test3@example.com"})
+      @server.acquisitions.should_not include({ "email" => "test4@example.com"})
+    end
+  end
+
+  it "should send all data in synchronous mode" do
+    with_constants('PirateMetrics::Agent::MAX_BUFFER' => 3) do
+      5.times do |i|
+        @agent.acquisition!({ :email => "test#{i}@example.com"})
+      end
+      @agent.instance_variable_get(:@queue).size.should == 0
+      wait
+      @server.acquisitions.should include({ "email" => "test0@example.com"})
+      @server.acquisitions.should include({ "email" => "test1@example.com"})
+      @server.acquisitions.should include({ "email" => "test2@example.com"})
+      @server.acquisitions.should include({ "email" => "test3@example.com"})
+      @server.acquisitions.should include({ "email" => "test4@example.com"})
+    end
+  end
+
+  it "should send all data in synchronous mode (agent-level)" do
+    with_constants('PirateMetrics::Agent::MAX_BUFFER' => 3) do
+      @agent.synchronous = true
+      5.times do |i|
+        @agent.acquisition({ :email => "test#{i}@example.com"})
+      end
+      @agent.instance_variable_get(:@queue).size.should == 0
+      wait
+      @server.acquisitions.should include({ "email" => "test0@example.com"})
+      @server.acquisitions.should include({ "email" => "test1@example.com"})
+      @server.acquisitions.should include({ "email" => "test2@example.com"})
+      @server.acquisitions.should include({ "email" => "test3@example.com"})
+      @server.acquisitions.should include({ "email" => "test4@example.com"})
+    end
+  end
+
+  it "should automatically reconnect when forked" do
+    wait
+    @agent.acquisition({ :email => "test0@example.com"})
+    fork do
+      @agent.acquisition({ :email => "test1@example.com"})
+    end
+    wait
+    @agent.acquisition({ :email => "test2@example.com"})
+    wait
+    @server.acquisitions.should include({ "email" => "test0@example.com"})
+    @server.acquisitions.should include({ "email" => "test1@example.com"})
+    @server.acquisitions.should include({ "email" => "test2@example.com"})
+  end
+
+  it "should never let an exception reach the user" do
+    @agent.stub!(:send_metric).and_raise(Exception.new("Test Exception"))
+    @agent.acquisition({ :email => "test@example.com"}).should be_nil
+    wait
+    @agent.activation({ :email => "test@example.com"}).should be_nil
+    wait
+  end
+
+  it "should allow outgoing metrics to be stopped" do
+    tm = Time.now
+    @agent.acquisition({ :email => "testbad@example.com"})
+    @agent.stop
+    wait
+    @agent.acquisition({ :email => "testgood@example.com"})
+    wait
+    @server.acquisitions.should_not include({ "email" => "testbad@example.com"})
+    @server.acquisitions.should include({ "email" => "testgood@example.com"})
+  end
+
+  it "should allow flushing pending values to the server" do
+    1.upto(100) { |i| @agent.acquisition({ :email => "test#{i}@example.com"}) }
+    @agent.instance_variable_get(:@queue).size.should >= 100
+    @agent.flush
+    @agent.instance_variable_get(:@queue).size.should ==  0
+    wait
+    @server.acquisitions.size.should == 100
+  end
+
+  it "should no op on an empty flush" do
+    @agent.flush(true)
+    wait
+    @server.connect_count.should == 0
+  end
+end
+
+describe PirateMetrics::Agent, "connection problems" do
+  after do
+    @agent.stop
+    @server.stop
+  end
+
+  it "should automatically reconnect on disconnect" do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+    @agent.acquisition({ :email => "test1@example.com"})
+    wait
+    @server.disconnect_all
+    wait
+    @agent.acquisition({ :email => "test2@example.com"})
+    wait
+    @server.connect_count.should == 2
+    @server.acquisitions.last.should == { "email" => "test2@example.com"}
+  end
+
+  it "should buffer commands when server is down" do
+    @server = TestServer.new(:listen => false)
+    @agent = @server.fresh_agent
+    wait
+    @agent.retention({ :email => "test@example.com"})
+    wait
+    @agent.queue.size.should == 1
+  end
+
+  it "should send commands in a short-lived process" do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+    if pid = fork { @agent.acquisition({ :email => "test@example.com"}) }
+      Process.wait(pid)
+      @server.acquisitions.size.should == 1
+    end
+  end
+
+  it "should send commands in a process that bypasses at_exit when using #cleanup" do
+    @server = TestServer.new
+    @agent = @server.fresh_agent
+    if pid = fork { @agent.acquisition({ :email => "test@example.com"}); @agent.cleanup; exit! }
+      Process.wait(pid)
+      @server.acquisitions.size.should == 1
+    end
+  end
+end
+
+describe PirateMetrics::Agent, "enabled with sync option" do
+  before do
+    @server = TestServer.new
+    @agent = @server.fresh_agent({ :synchronous => true})
+  end
+
+  after do
+    @agent.stop
+    @server.stop
+  end
+
+  it "should send all data in synchronous mode" do
+    with_constants('PirateMetrics::Agent::MAX_BUFFER' => 3) do
+      5.times do |i|
+        @agent.acquisition({ :email => "test#{i}@example.com"})
+      end
+      wait # let the server receive the commands
+      @server.acquisitions.should include({ "email" => "test0@example.com"})
+      @server.acquisitions.should include({ "email" => "test1@example.com"})
+      @server.acquisitions.should include({ "email" => "test2@example.com"})
+      @server.acquisitions.should include({ "email" => "test3@example.com"})
+      @server.acquisitions.should include({ "email" => "test4@example.com"})
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,72 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'pirate_metrics_agent'
+require 'test_server'
+
+RSpec.configure do |config|
+
+  config.before(:all) do
+  end
+
+  config.after(:all) do
+  end
+
+end
+
+
+def parse_constant(constant)
+  constant = constant.to_s
+  parts = constant.split("::")
+  constant_name = parts.pop
+  source = parts.join("::")
+  [source.constantize, constant_name]
+end
+
+def with_constants(constants, &block)
+  saved_constants = {}
+  constants.each do |constant, val|
+    source_object, const_name = parse_constant(constant)
+
+    saved_constants[constant] = source_object.const_get(const_name)
+    Kernel::silence_warnings { source_object.const_set(const_name, val) }
+  end
+
+  begin
+    block.call
+  ensure
+    constants.each do |constant, val|
+      source_object, const_name = parse_constant(constant)
+
+      Kernel::silence_warnings { source_object.const_set(const_name, saved_constants[constant]) }
+    end
+  end
+end
+alias :with_constant :with_constants
+
+class String
+  # From Rails
+  def constantize
+    names = split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+end
+
+module Kernel
+  # File activesupport/lib/active_support/core_ext/kernel/reporting.rb, line 10
+  def silence_warnings
+    with_warnings(nil) { yield }
+  end
+
+  def with_warnings(flag)
+    old_verbose, $VERBOSE = $VERBOSE, flag
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end

data/spec/test_server.rb

@@ -0,0 +1,97 @@
+require 'rack'
+
+class TestServer
+  attr_accessor :host, :port, :connect_count, :metrics, :last_api_key
+
+  def initialize(options={})
+    default_options = {
+      :listen => true,
+      :authenticate => true,
+      :response => true,
+    }
+    @options = default_options.merge(options)
+
+    @connect_count = 0
+    @connections = []
+    @metrics = Hash.new{ |h,k| h[k] = Array.new}
+    @last_api_key = ""
+    @host = 'http://localhost'
+    @main_thread = nil
+    @response = options[:response]
+    listen if @options[:listen]
+  end
+
+  def listen
+    @port ||= 10001
+    @server = TCPServer.new(@port)
+    @main_thread = Thread.new do
+      begin
+        loop do
+          begin
+            client = @server.accept
+            @connections << client
+            @connect_count += 1
+
+            while command = client.readline
+              if command.start_with? 'POST'
+                metric = command[/v1\/(.*)\sHTTP/, 1]
+              end
+              if command.start_with? "Content-Length: "
+                content_length = command.gsub("Content-Length: ", "").to_i
+              end
+              break if command == "\r\n"
+            end
+            content = client.read(content_length)
+            payload = Rack::Utils.parse_nested_query(content)
+            @metrics[metric] += payload["data"]
+            @last_api_key = payload[:api_key]
+
+            headers = ["HTTP/1.1 200 OK"].join("\r\n")
+            client.puts headers
+            client.close
+          rescue Exception => e
+            puts "Error in test server: #{e.inspect}"
+          end
+        end
+      end
+    end
+
+  rescue Errno::EADDRINUSE => err
+    puts "#{err.inspect} failed to get port #{@port}"
+    puts err.message
+    @port += 1
+    retry
+  end
+
+  def host_and_port
+    "#{host}:#{port}"
+  end
+
+  def stop
+    @stopping = true
+    disconnect_all
+    @main_thread.kill if @main_thread
+    @main_thread = nil
+    begin
+      @server.close if @server
+    rescue Exception => e
+    end
+  end
+
+  def disconnect_all
+    @connections.each { |c|
+      c.close rescue false
+    }
+    @connections = []
+  end
+
+  def fresh_agent(options = { })
+    PirateMetrics::Agent.new('test_token', { :host => host, :port => port, :enabled => true}.merge(options))
+  end
+
+  [:acquisitions, :activations, :retentions, :referrals, :revenues].each do |metric|
+    define_method metric do
+      @metrics[metric.to_s]
+    end
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: pirate_metrics_agent
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Elijah Miller
+- Christopher Zelenak
+- Kristopher Chambers
+- Matthew Hassfurder
+- Expected Behavior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Get to know your customers.
+email:
+- support@piratemetrics.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/pirate_metrics/agent.rb
+- lib/pirate_metrics/system_timer.rb
+- lib/pirate_metrics/version.rb
+- lib/pirate_metrics_agent.rb
+- pirate_metrics_agent.gemspec
+- spec/agent_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb
+homepage: http://github.com/expectedbehavior/pirate_metrics_agent
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Agent for reporting data to piratemetrics.com
+test_files:
+- spec/agent_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb