instrumental_agent 0.13.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e7ed24aefecf9dcaafe0e844de778dbffcdee97
-  data.tar.gz: 0e02a6016b87304d08510dec4018d589b9b58b19
+  metadata.gz: a5faedb2800827d3604f4a6c0b13bd33234d55ec
+  data.tar.gz: a0115cc25b12d9749dcfeef580bfb26734001e21
 SHA512:
-  metadata.gz: cc097c786b1b97206883cc0049f2841b1a9913a4364597ed0200f9ccb13fe91be118a1dbab1d90c774c0e014c11905b1f1da2d8a571669386c2b634b08273856
-  data.tar.gz: 05e415812768a7bc6df4095d7a0ad820c8ca8061a8a817e06fcab18490451e3be107c31602703da8b5217339a0dbb7a53724aa60f84d1256763baf6452ba7b83
+  metadata.gz: 282bb711342714bdb4be0a1afec481f39bb6fd9fce58f001a9ba662ae10e17ddade912743b85bcf87a8f026b8db0c873d420e9ecffcb213cb5e047a018794886
+  data.tar.gz: a3114f1773d7442e74d9775906324eb8717ad799980668e0dc0be7a1f754196c34331f9859603249c115f748a7934248762329f275f6022135837019524d8f5d

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 1.0.0 [May 13, 2016]
+* No significant code changes
+
 ### 0.13.4 [October 6, 2015]
 * Fixes for when agent times out communicating with server
 
@@ -68,7 +71,7 @@
 * Fix for dead lock issuew
 
 ### 0.9.5 [March 23rd, 2012]
-* Defer startup of agent thread until metrics are submitted - this update is strongly recommended for anyone using Ruby Enterprise Edition in concert w/ a preforking application server (like Phusion Passenger).  See the [REE wiki page](https://github.com/expectedbehavior/instrumental_agent/wiki/Using-with-Ruby-Enterprise-Edition) for more information.
+* Defer startup of agent thread until metrics are submitted - this update is strongly recommended for anyone using Ruby Enterprise Edition in concert w/ a preforking application server (like Phusion Passenger).
 * Add .stop method for cancelling agent processing
 * Changes to how defaults are processed at initialization
 * Documentation for usage w/ Resque and Resque like scenarios
@@ -115,7 +118,7 @@
 * Code cleanup
 
 ### 0.5.1 [December 12, 2011]
-* instrument_server moved to instrumental_tools gem (https://github.com/expectedbehavior/instrumental_tools)
+* instrument_server moved to instrumental_tools gem (https://github.com/instrumental/instrumental_tools)
 
 ### 0.5 [December 9, 2011]
 * Allow negative numbers to be submitted

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Fastest Forward
+Copyright (c) 2016 Expected Behavior
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,6 +1,8 @@
-# Instrumental Agent
+# Instrumental Ruby Agent
 
-Measure your application in real time.
+Instrumental is a [application monitoring platform](https://instrumentalapp.com) built for developers who want a better understanding of their production software. Powerful tools, like the [Instrumental Query Language](https://instrumentalapp.com/docs/query-language), combined with an exploration-focused interface allow you to get real answers to complex questions, in real-time.
+
+This agent supports custom metric monitoring for Ruby applications. It provides high-data reliability at high scale, without ever blocking your process or causing an exception. 
 
 ## Setup & Usage
 
@@ -10,17 +12,17 @@ Add the gem to your Gemfile.
 gem 'instrumental_agent'
 ```
 
-Visit [instrumentalapp.com](https://instrumentalapp.com) and create an account, then  initialize the agent with your API key, found in the Docs section.
+Visit [instrumentalapp.com](https://instrumentalapp.com) and create an account, then initialize the agent with your API key, found in the Docs section.
 
-```sh
+```ruby
 I = Instrumental::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.
+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 Instrumental to track your application.
 
-```sh
+```ruby
 I.gauge('load', 1.23)                # value at a point in time
 
 I.increment('signups')               # increasing value, think "events"
@@ -37,20 +39,20 @@ end
 
 Want to track an event (like an application deploy, or downtime)? You can capture events that are instantaneous, or events that happen over a period of time.
 
-```sh
+```ruby
 I.notice('Jeffy deployed rev ef3d6a') # instantaneous event
 I.notice('Testing socket buffer increase', 3.days.ago, 20.minutes) # an event with a duration
 ```
 
 ## Backfilling
 
-Streaming data is better with a little historical context. Instrumental lets you  backfill data, allowing you to see deep into your project's past.
+Streaming data is better with a little historical context. Instrumental lets you backfill data, allowing you to see deep into your project's past.
 
 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. We provide a synchronous mode that will ensure every stat makes it to Instrumental before continuing on to the next.
 
 **Warning**: You should only enable synchronous mode for backfilling data as any issues with the Instrumental service issues will cause this code to halt until it can reconnect.
 
-```sh
+```ruby
 I.synchronous = true # every command sends immediately
 User.find_each do |user|
   I.increment('signups', 1, user.created_at)
@@ -59,7 +61,7 @@ end
 
 ## Server Stats
 
-Want some general server stats (load, memory, etc.)? Check out the [instrumental_tools](https://github.com/expectedbehavior/instrumental_tools) gem.
+Want some general server stats (load, memory, etc.)? Check out the [instrumental_tools](https://github.com/instrumental/instrumental_tools) gem.
 
 ```sh
 gem install instrumental_tools
@@ -73,7 +75,7 @@ Need to quickly disable the agent? set :enabled to false on initialization and y
 
 ## Capistrano Integration
 
-Add `require "instrumental/capistrano"` to your capistrano configuration and your deploys will be tracked by Instrumental.  Add the API token for the project you want to track to by setting the following Capistrano var:
+Add `require "instrumental/capistrano"` to your capistrano configuration and your deploys will be tracked by Instrumental. Add the API token for the project you want to track to by setting the following Capistrano var:
 
 ```ruby
 set :instrumental_key, "MY_API_KEY"
@@ -93,15 +95,30 @@ The default message sent is "USER deployed COMMIT_HASH". If you need to customiz
 
 ## 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/resque/resque/blob/master/docs/HOOKS.md) for more information.
+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/resque/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 Instrumental 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 `I.cleanup` to ensure any pending metrics are correctly sent to the server before exiting the process.
-
-## Using with Ruby Enterprise Edition
-
-Users of Ruby Enterprise Edition should plan on using version 0.9.5 of the Instrumental Agent or greater. Please see the [REE wiki page](https://github.com/fastestforward/instrumental_agent/wiki/Using-with-Ruby-Enterprise-Edition) 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 Instrumental 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 `I.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@instrumentalapp.com](mailto:support@instrumentalapp.com).
+
+
+## Release Process
+
+1. Pull latest master
+2. Merge feature branch(es) into master
+3. `script/test`
+4. Increment version in:
+  - `lib/instrumental/version.rb`
+5. Update [CHANGELOG.md](CHANGELOG.md)
+6. Commit "Release vX.Y.Z"
+7. Push to GitHub
+8. Release packages: `rake release`
+9. Update documentation on instrumentalapp.com
+
+
+## Version Policy
+
+This library follows [Semantic Versioning 2.0.0](http://semver.org).

data/instrumental_agent.gemspec

@@ -6,9 +6,9 @@ Gem::Specification.new do |s|
   s.version     = Instrumental::VERSION
   s.authors     = ["Elijah Miller", "Christopher Zelenak", "Kristopher Chambers", "Matthew Hassfurder"]
   s.email       = ["support@instrumentalapp.com"]
-  s.homepage    = "http://github.com/expectedbehavior/instrumental_agent"
-  s.summary     = %q{Agent for reporting data to instrumentalapp.com}
-  s.description = %q{Track anything.}
+  s.homepage    = "http://github.com/instrumental/instrumental_agent-ruby"
+  s.summary     = %q{Custom metric monitoring for Ruby applications via Instrumental}
+  s.description = %q{This agent supports Instrumental custom metric monitoring for Ruby applications. It provides high-data reliability at high scale, without ever blocking your process or causing an exception.}
   s.license     = "MIT"
 
 
@@ -16,7 +16,8 @@ Gem::Specification.new do |s|
   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<rspec>, ["~> 2.0"])
-  s.add_development_dependency(%q<fuubar>, [">= 0"])
+  s.add_development_dependency("pry", [">= 0"])
+  s.add_development_dependency("rake", [">= 0"])
+  s.add_development_dependency("rspec", ["~> 3.0"])
+  s.add_development_dependency("fuubar", [">= 0"])
 end

data/lib/instrumental/version.rb

@@ -1,3 +1,3 @@
 module Instrumental
-  VERSION = "0.13.4"
+  VERSION = "1.0.0"
 end

data/script/setup

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+cd "$(dirname "$0")/.."
+
+type rbenv || $(brew install rbenv; brew install ruby-build)
+rbenv which ruby || $(brew upgrade ruby-build || true; rbenv install)
+gem list -i bundler || gem install bundler
+bundle install

data/script/test

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+cd "$(dirname "$0")/.."
+
+script/setup
+bundle exec rspec

data/spec/agent_spec.rb

@@ -47,38 +47,38 @@ shared_examples "Instrumental Agent" do
       let(:enabled) { false }
 
       it "should not connect to the server" do
-        server.connect_count.should == 0
+        expect(server.connect_count).to eq(0)
       end
 
       it "should not connect to the server after receiving a metric" do
         agent.gauge('disabled_test', 1)
         wait
-        server.connect_count.should == 0
+        expect(server.connect_count).to eq(0)
       end
 
       it "should no op on flush without reconnect" do
         1.upto(100) { agent.gauge('disabled_test', 1) }
         agent.flush(false)
         wait
-        server.commands.should be_empty
+        expect(server.commands).to be_empty
       end
 
       it "should no op on flush with reconnect" do
         1.upto(100) { agent.gauge('disabled_test', 1) }
         agent.flush(true)
         wait
-        server.commands.should be_empty
+        expect(server.commands).to be_empty
       end
 
       it "should no op on an empty flush" do
         agent.flush(true)
         wait
-        server.commands.should be_empty
+        expect(server.commands).to be_empty
       end
 
       it "should send metrics to logger" do
         now = Time.now
-        agent.logger.should_receive(:debug).with("gauge metric 1 #{now.to_i} 1")
+        expect(agent.logger).to receive(:debug).with("gauge metric 1 #{now.to_i} 1")
         agent.gauge("metric", 1)
       end
     end
@@ -86,97 +86,106 @@ shared_examples "Instrumental Agent" do
     describe Instrumental::Agent, "enabled" do
 
       it "should not connect to the server" do
-        server.connect_count.should == 0
+        expect(server.connect_count).to eq(0)
       end
 
       it "should connect to the server after sending a metric" do
         agent.increment("test.foo")
         wait
-        server.connect_count.should == 1
+        expect(server.connect_count).to eq(1)
       end
 
       it "should announce itself, and include version" do
         agent.increment("test.foo")
         wait
-        server.commands[0].should =~ /hello .*/
-        server.commands[0].should =~ / version /
-        server.commands[0].should =~ / hostname /
-        server.commands[0].should =~ / pid /
-        server.commands[0].should =~ / runtime /
-        server.commands[0].should =~ / platform /
+        expect(server.commands[0]).to match(/hello .*/)
+        expect(server.commands[0]).to match(/ version /)
+        expect(server.commands[0]).to match(/ hostname /)
+        expect(server.commands[0]).to match(/ pid /)
+        expect(server.commands[0]).to match(/ runtime /)
+        expect(server.commands[0]).to match(/ platform /)
       end
 
       it "should authenticate using the token" do
         agent.increment("test.foo")
         wait
-        server.commands[1].should == "authenticate test_token"
+        expect(server.commands[1]).to eq("authenticate test_token")
       end
 
       it "should report a gauge" do
         now = Time.now
         agent.gauge('gauge_test', 123)
         wait
-        server.commands.last.should == "gauge gauge_test 123 #{now.to_i} 1"
+        expect(server.commands.last).to eq("gauge gauge_test 123 #{now.to_i} 1")
       end
 
       it "should report a time as gauge and return the block result" do
         now = Time.now
-        agent.time("time_value_test") do
+        return_value = agent.time("time_value_test") do
           1 + 1
-        end.should == 2
+        end
+        expect(return_value).to eq(2)
         wait
-        server.commands.last.should =~ /gauge time_value_test .* #{now.to_i}/
+        expect(server.commands.last).to match(/gauge time_value_test .* #{now.to_i}/)
       end
 
-      it "should return the value gauged" do
-        now = Time.now
-        agent.gauge('gauge_test', 123).should == 123
-        agent.gauge('gauge_test', 989).should == 989
+      it "should report a time_ms as gauge and return the block result" do
+        allow(Time).to receive(:now).and_return(100)
+        return_value = agent.time_ms("time_value_test") do
+          allow(Time).to receive(:now).and_return(101)
+          1 + 1
+        end
+        expect(return_value).to eq(2)
         wait
+        expect(server.commands.last).to match(/gauge time_value_test 1000/)
+      end
+
+      it "should return the value gauged" do
+        expect(agent.gauge('gauge_test', 123)).to eq(123)
+        expect(agent.gauge('gauge_test', 989)).to eq(989)
       end
 
       it "should report a gauge with a set time" do
         agent.gauge('gauge_test', 123, 555)
         wait
-        server.commands.last.should == "gauge gauge_test 123 555 1"
+        expect(server.commands.last).to eq("gauge gauge_test 123 555 1")
       end
 
       it "should report a gauge with a set time and count" do
         agent.gauge('gauge_test', 123, 555, 111)
         wait
-        server.commands.last.should == "gauge gauge_test 123 555 111"
+        expect(server.commands.last).to eq("gauge gauge_test 123 555 111")
       end
 
       it "should report an increment" do
         now = Time.now
         agent.increment("increment_test")
         wait
-        server.commands.last.should == "increment increment_test 1 #{now.to_i} 1"
+        expect(server.commands.last).to eq("increment increment_test 1 #{now.to_i} 1")
       end
 
       it "should return the value incremented by" do
-        now = Time.now
-        agent.increment("increment_test").should == 1
-        agent.increment("increment_test", 5).should == 5
+        expect(agent.increment("increment_test")).to eq(1)
+        expect(agent.increment("increment_test", 5)).to eq(5)
       end
 
       it "should report an increment a value" do
         now = Time.now
         agent.increment("increment_test", 2)
         wait
-        server.commands.last.should == "increment increment_test 2 #{now.to_i} 1"
+        expect(server.commands.last).to eq("increment increment_test 2 #{now.to_i} 1")
       end
 
       it "should report an increment with a set time" do
         agent.increment('increment_test', 1, 555)
         wait
-        server.commands.last.should == "increment increment_test 1 555 1"
+        expect(server.commands.last).to eq("increment increment_test 1 555 1")
       end
 
       it "should report an increment with a set time and count" do
         agent.increment('increment_test', 1, 555, 111)
         wait
-        server.commands.last.should == "increment increment_test 1 555 111"
+        expect(server.commands.last).to eq("increment increment_test 1 555 111")
       end
 
       it "should discard data that overflows the buffer" do
@@ -185,12 +194,11 @@ shared_examples "Instrumental Agent" do
             agent.increment('overflow_test', i + 1, 300)
           end
           wait
-          server.commands.should     include("increment overflow_test 1 300 1")
-          server.commands.should     include("increment overflow_test 2 300 1")
-          server.commands.should     include("increment overflow_test 3 300 1")
-
-          server.commands.should_not include("increment overflow_test 4 300 1")
-          server.commands.should_not include("increment overflow_test 5 300 1")
+          expect(server.commands).to include("increment overflow_test 1 300 1")
+          expect(server.commands).to include("increment overflow_test 2 300 1")
+          expect(server.commands).to include("increment overflow_test 3 300 1")
+          expect(server.commands).to_not include("increment overflow_test 4 300 1")
+          expect(server.commands).to_not include("increment overflow_test 5 300 1")
         end
       end
 
@@ -200,13 +208,13 @@ shared_examples "Instrumental Agent" do
           5.times do |i|
             agent.increment('overflow_test', i + 1, 300)
           end
-          agent.instance_variable_get(:@queue).size.should == 0
+          expect(agent.instance_variable_get(:@queue).size).to eq(0)
           wait # let the server receive the commands
-          server.commands.should include("increment overflow_test 1 300 1")
-          server.commands.should include("increment overflow_test 2 300 1")
-          server.commands.should include("increment overflow_test 3 300 1")
-          server.commands.should include("increment overflow_test 4 300 1")
-          server.commands.should include("increment overflow_test 5 300 1")
+          expect(server.commands).to include("increment overflow_test 1 300 1")
+          expect(server.commands).to include("increment overflow_test 2 300 1")
+          expect(server.commands).to include("increment overflow_test 3 300 1")
+          expect(server.commands).to include("increment overflow_test 4 300 1")
+          expect(server.commands).to include("increment overflow_test 5 300 1")
         end
       end
 
@@ -219,38 +227,38 @@ shared_examples "Instrumental Agent" do
           wait(1)
           agent.increment('fork_reconnect_test', 1, 4) # triggers reconnect
           wait(1)
-          server.connect_count.should == 2
-          server.commands.should include("increment fork_reconnect_test 1 2 1")
-          server.commands.should include("increment fork_reconnect_test 1 3 1")
-          server.commands.should include("increment fork_reconnect_test 1 4 1")
+          expect(server.connect_count).to eq(2)
+
+          expect(server.commands).to include("increment fork_reconnect_test 1 2 1")
+          expect(server.commands).to include("increment fork_reconnect_test 1 3 1")
+          expect(server.commands).to include("increment fork_reconnect_test 1 4 1")
         end
       end
 
       it "should never let an exception reach the user" do
-        agent.stub(:send_command).and_raise(Exception.new("Test Exception"))
-        agent.increment('throws_exception', 2).should be_nil
-        wait
-        agent.gauge('throws_exception', 234).should be_nil
+        expect(agent).to receive(:send_command).twice { raise(Exception.new("Test Exception")) }
+        expect(agent.increment('throws_exception', 2)).to eq(nil)
         wait
+        expect(agent.increment('throws_exception', 234)).to eq(nil)
       end
 
       it "should let exceptions in time bubble up" do
-        expect { agent.time('za') { raise "fail" } }.to raise_error
+        expect { agent.time('za') { raise "fail" } }.to raise_exception(StandardError)
       end
 
       it "should return nil if the user overflows the MAX_BUFFER" do
-        Queue.any_instance.stub(:pop) { nil }
+        allow_any_instance_of(Queue).to receive(:pop).and_return(nil)
         1.upto(Instrumental::Agent::MAX_BUFFER) do
-          agent.increment("test").should == 1
+          expect(agent.increment("test")).to eq(1)
         end
-        agent.increment("test").should be_nil
+        expect(agent.increment("test")).to eq(nil)
       end
 
       it "should track invalid metrics" do
-        agent.logger.should_receive(:warn).with(/%%/)
+        expect(agent.logger).to receive(:warn).with(/%%/)
         agent.increment(' %% .!#@$%^&*', 1, 1)
         wait
-        server.commands.join("\n").should include("increment agent.invalid_metric")
+        expect(server.commands.join("\n")).to include("increment agent.invalid_metric")
       end
 
       it "should allow reasonable metric names" do
@@ -259,14 +267,14 @@ shared_examples "Instrumental Agent" do
         agent.increment('hello.world')
         agent.increment('ThisIsATest.Of.The.Emergency.Broadcast.System.12345')
         wait
-        server.commands.join("\n").should_not include("increment agent.invalid_metric")
+        expect(server.commands.join("\n")).to_not include("increment agent.invalid_metric")
       end
 
       it "should track invalid values" do
-        agent.logger.should_receive(:warn).with(/hello.*testington/)
+        expect(agent.logger).to receive(:warn).with(/hello.*testington/)
         agent.increment('testington', 'hello')
         wait
-        server.commands.join("\n").should include("increment agent.invalid_value")
+        expect(server.commands.join("\n")).to include("increment agent.invalid_value")
       end
 
       it "should allow reasonable values" do
@@ -279,20 +287,20 @@ shared_examples "Instrumental Agent" do
         agent.increment('a',  333.333)
         agent.increment('a',  Float::EPSILON)
         wait
-        server.commands.join("\n").should_not include("increment agent.invalid_value")
+        expect(server.commands.join("\n")).to_not include("increment agent.invalid_value")
       end
 
       it "should send notices to the server" do
         tm = Time.now
         agent.notice("Test note", tm)
         wait
-        server.commands.join("\n").should include("notice #{tm.to_i} 0 Test note")
+        expect(server.commands.join("\n")).to include("notice #{tm.to_i} 0 Test note")
       end
 
       it "should prevent a note w/ newline characters from being sent to the server" do
-        agent.notice("Test note\n").should be_nil
+        expect(agent.notice("Test note\n")).to eq(nil)
         wait
-        server.commands.join("\n").should_not include("notice Test note")
+        expect(server.commands.join("\n")).to_not include("notice Test note")
       end
 
       it "should allow outgoing metrics to be stopped" do
@@ -302,23 +310,23 @@ shared_examples "Instrumental Agent" do
         wait
         agent.increment("foo.baz", 1, tm)
         wait
-        server.commands.join("\n").should include("increment foo.baz 1 #{tm.to_i}")
-        server.commands.join("\n").should_not include("increment foo.bar 1 #{tm.to_i}")
+        expect(server.commands.join("\n")).to include("increment foo.baz 1 #{tm.to_i}")
+        expect(server.commands.join("\n")).to_not include("increment foo.bar 1 #{tm.to_i}")
       end
 
       it "should allow flushing pending values to the server" do
         1.upto(100) { agent.gauge('a', rand(50)) }
-        agent.instance_variable_get(:@queue).size.should > 0
+        expect(agent.instance_variable_get(:@queue).size).to be > 0
         agent.flush
-        agent.instance_variable_get(:@queue).size.should ==  0
+        expect(agent.instance_variable_get(:@queue).size).to eq(0)
         wait
-        server.commands.grep(/^gauge a /).size.should == 100
+        expect(server.commands.grep(/^gauge a /).size).to eq(100)
       end
 
       it "should no op on an empty flush" do
         agent.flush(true)
         wait
-        server.commands.should be_empty
+        expect(server.commands).to be_empty
       end
     end
 
@@ -330,9 +338,9 @@ shared_examples "Instrumental Agent" do
         wait(1)
         agent.increment('reconnect_test', 1, 5678) # triggers reconnect
         wait(1)
-        server.connect_count.should == 2
+        expect(server.connect_count).to eq(2)
         # Ensure the last command sent has been received after the reconnect attempt
-        server.commands.last.should == "increment reconnect_test 1 5678 1"
+        expect(server.commands.last).to eq("increment reconnect_test 1 5678 1")
       end
 
       context 'not listening' do
@@ -343,13 +351,13 @@ shared_examples "Instrumental Agent" do
           agent.increment('reconnect_test', 1, 1234)
           wait
           # The agent should not have sent the metric yet, the server is not responding
-          agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+          expect(agent.queue.pop(true)).to include("increment reconnect_test 1 1234 1\n")
         end
 
         it "should warn once when buffer is full" do
           with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
             wait
-            agent.logger.should_receive(:warn).with(/Queue full/).once
+            expect(agent.logger).to receive(:warn).with(/Queue full/).once
 
             agent.increment('buffer_full_warn_test', 1, 1234)
             agent.increment('buffer_full_warn_test', 1, 1234)
@@ -361,13 +369,12 @@ shared_examples "Instrumental Agent" do
       end
 
       context 'bad address' do
-        let(:address) { "nope:9999" }
+        let(:address) { "bad-address:9999" }
 
         it "should not be running if it cannot connect" do
+          expect(Resolv).to receive(:getaddresses).with("bad-address").and_raise Resolv::ResolvError
           agent.gauge('connection_test', 1, 1234)
-          # nope:9999 does not resolve to anything, the agent will not resolve
-          # the address and refuse to start a worker thread
-          agent.should_not be_running
+          expect(agent.send(:running?)).to eq(false)
         end
       end
 
@@ -379,7 +386,7 @@ shared_examples "Instrumental Agent" do
           agent.increment('reconnect_test', 1, 1234)
           wait
           # Since server hasn't responded to hello or authenticate, worker thread will not send data
-          agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+          expect(agent.queue.pop(true)).to include("increment reconnect_test 1 1234 1\n")
         end
       end
 
@@ -396,9 +403,8 @@ shared_examples "Instrumental Agent" do
           wait
           # The agent thread should have stopped running since the network write would
           # have failed. The queue will still contain the metric that has yet to be sent
-          agent.should_not be_running
-          agent.queue.size.should == 1
-
+          expect(agent.send(:running?)).to eq(false)
+          expect(agent.queue.size).to eq(1)
         end
 
         it "should restart the worker thread after hanging it up during an unreachable host event" do
@@ -413,8 +419,8 @@ shared_examples "Instrumental Agent" do
           wait
           # The agent thread should have stopped running since the network write would
           # have failed. The queue will still contain the metric that has yet to be sent
-          agent.should_not be_running
-          agent.queue.size.should == 1
+          expect(agent.send(:running?)).to eq(false)
+          expect(agent.queue.size).to eq(1)
           wait
           # Start the server back up again
           server.listen
@@ -423,8 +429,8 @@ shared_examples "Instrumental Agent" do
           agent.gauge('connection_failure', 1, 1234)
           wait
           # The agent should now be running the background thread, and the queue should be empty
-          agent.should be_running
-          agent.queue.size.should == 0
+          expect(agent.send(:running?)).to eq(true)
+          expect(agent.queue.size).to eq(0)
         end
 
       end
@@ -438,7 +444,7 @@ shared_examples "Instrumental Agent" do
           agent.increment('reconnect_test', 1, 1234)
           wait
           # Metrics should not have been sent since all authentication failed
-          agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+          expect(agent.queue.pop(true)).to include("increment reconnect_test 1 1234 1\n")
         end
       end
 
@@ -447,7 +453,7 @@ shared_examples "Instrumental Agent" do
           if pid = fork { agent.increment('foo', 1, 1234) }
             Process.wait(pid)
             # The forked process should have flushed and waited on at_exit
-            server.commands.last.should == "increment foo 1 1234 1"
+            expect(server.commands.last).to eq("increment foo 1 1234 1")
           end
         end
 
@@ -455,31 +461,31 @@ shared_examples "Instrumental Agent" do
           if pid = fork { agent.increment('foo', 1, 1234); agent.cleanup; exit! }
             Process.wait(pid)
             # The forked process should have flushed and waited on at_exit since cleanup was called explicitly
-            server.commands.last.should == "increment foo 1 1234 1"
+            expect(server.commands.last).to eq("increment foo 1 1234 1")
           end
         end
 
         it "should not wait longer than EXIT_FLUSH_TIMEOUT seconds to exit a process" do
-          agent.stub(:open_socket) { |*args, &block| sleep(5) && block.call }
+          allow(agent).to receive(:open_socket) { |*args, &block| sleep(5) && block.call }
           with_constants('Instrumental::Agent::EXIT_FLUSH_TIMEOUT' => 3) do
             if (pid = fork { agent.increment('foo', 1) })
               tm = Time.now.to_f
               Process.wait(pid)
               diff = Time.now.to_f - tm
-              diff.abs.should >= 3
-              diff.abs.should < 5
+              expect(diff.abs).to be >= 3
+              expect(diff.abs).to be < 5
             end
           end
         end
 
         it "should not wait to exit a process if there are no commands queued" do
-          agent.stub(:open_socket) { |*args, &block| sleep(5) && block.call }
+          allow(agent).to receive(:open_socket) { |*args, &block| sleep(5) && block.call }
           with_constants('Instrumental::Agent::EXIT_FLUSH_TIMEOUT' => 3) do
             if (pid = fork { agent.increment('foo', 1); agent.queue.clear })
               tm = Time.now.to_f
               Process.wait(pid)
               diff = Time.now.to_f - tm
-              diff.should < 1
+              expect(diff).to be < 1
             end
           end
         end
@@ -488,7 +494,7 @@ shared_examples "Instrumental Agent" do
       it "should not wait longer than EXIT_FLUSH_TIMEOUT to attempt flushing the socket when disconnecting" do
         agent.increment('foo', 1)
         wait
-        agent.should_receive(:flush_socket) do
+        expect(agent).to receive(:flush_socket) do
           r, w = IO.pipe
           Thread.new do
             IO.select([r]) # mimic an endless blocking select poll
@@ -498,7 +504,7 @@ shared_examples "Instrumental Agent" do
           tm = Time.now.to_f
           agent.cleanup
           diff = Time.now.to_f - tm
-          diff.should <= 3
+          expect(diff).to be <= 3
         end
       end
 
@@ -507,13 +513,13 @@ shared_examples "Instrumental Agent" do
                        'Instrumental::Agent::RESOLUTION_WAIT' => 2,
                        'Instrumental::Agent::RESOLVE_TIMEOUT' => 0.1) do
           attempted_resolutions = 0
-          Resolv.stub(:getaddresses) { attempted_resolutions +=1 ; sleep 1 }
+          allow(Resolv).to receive(:getaddresses) { attempted_resolutions +=1 ; sleep 1 }
           agent.gauge('test', 1)
-          attempted_resolutions.should == 1
-          agent.should_not be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(agent.send(:running?)).to eq(false)
           agent.gauge('test', 1)
-          attempted_resolutions.should == 1
-          agent.should_not be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(agent.send(:running?)).to eq(false)
         end
       end
 
@@ -522,16 +528,16 @@ shared_examples "Instrumental Agent" do
                        'Instrumental::Agent::RESOLUTION_WAIT' => 2,
                        'Instrumental::Agent::RESOLVE_TIMEOUT' => 0.1) do
           attempted_resolutions = 0
-          Resolv.stub(:getaddresses) { attempted_resolutions +=1 ; sleep 1 }
+          allow(Resolv).to receive(:getaddresses) { attempted_resolutions +=1 ; sleep 1 }
           agent.gauge('test', 1)
-          attempted_resolutions.should == 1
-          agent.should_not be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(agent.send(:running?)).to eq(false)
           agent.gauge('test', 1)
-          attempted_resolutions.should == 1
-          agent.should_not be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(agent.send(:running?)).to eq(false)
           sleep 2
           agent.gauge('test', 1)
-          attempted_resolutions.should == 2
+          expect(attempted_resolutions).to eq(2)
         end
       end
 
@@ -540,23 +546,23 @@ shared_examples "Instrumental Agent" do
           attempted_opens = 0
           open_sleep = 0
           os = agent.method(:open_socket)
-          agent.stub(:open_socket) { |*args, &block| attempted_opens +=1 ; sleep(open_sleep) && os.call(*args) }
+          allow(agent).to receive(:open_socket) { |*args, &block| attempted_opens +=1 ; sleep(open_sleep) && os.call(*args) }
 
           # Connect normally and start running worker loop
           attempted_resolutions = 0
           ga = Resolv.method(:getaddresses)
-          Resolv.stub(:getaddresses) { |*args, &block| attempted_resolutions +=1 ; ga.call(*args) }
+          allow(Resolv).to receive(:getaddresses) { |*args, &block| attempted_resolutions +=1 ; ga.call(*args) }
           agent.gauge('test', 1)
           wait 2
-          attempted_resolutions.should == 1
-          attempted_opens.should == 1
-          agent.should be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(attempted_opens).to eq(1)
+          expect(agent.send(:running?)).to eq(true)
 
           # Setup a failure for the next command so we'll break out of the inner
           # loop in run_worker_loop causing another call to open_socket
           test_connection_fail = true
           tc = agent.method(:test_connection)
-          agent.stub(:test_connection) { |*args, &block| test_connection_fail ? raise("fail") : tc.call(*args) }
+          allow(agent).to receive(:test_connection) { |*args, &block| test_connection_fail ? raise("fail") : tc.call(*args) }
 
           # Setup a timeout failure in open_socket for the next command
           open_sleep = 5
@@ -566,10 +572,10 @@ shared_examples "Instrumental Agent" do
           agent.gauge('test', 1)
           wait 5
           # On retry we attempt to open_socket, but this times out
-          attempted_opens.should == 2
+          expect(attempted_opens).to eq(2)
           # We don't resolve again yet, we just disconnect
-          attempted_resolutions.should == 1
-          agent.should_not be_running
+          expect(attempted_resolutions).to eq(1)
+          expect(agent.send(:running?)).to eq(false)
 
           # Make test_connection succeed on the next command
           test_connection_fail = false
@@ -580,9 +586,9 @@ shared_examples "Instrumental Agent" do
           # The reconnect causes a new DNS resolution
           agent.gauge('test', 1)
           wait 5
-          attempted_resolutions.should == 2
-          attempted_opens.should == 3
-          agent.should be_running
+          expect(attempted_resolutions).to eq(2)
+          expect(attempted_opens).to eq(3)
+          expect(agent.send(:running?)).to eq(true)
         end
       end
     end
@@ -596,11 +602,11 @@ shared_examples "Instrumental Agent" do
             agent.increment('overflow_test', i + 1, 300)
           end
           wait # let the server receive the commands
-          server.commands.should include("increment overflow_test 1 300 1")
-          server.commands.should include("increment overflow_test 2 300 1")
-          server.commands.should include("increment overflow_test 3 300 1")
-          server.commands.should include("increment overflow_test 4 300 1")
-          server.commands.should include("increment overflow_test 5 300 1")
+          expect(server.commands).to include("increment overflow_test 1 300 1")
+          expect(server.commands).to include("increment overflow_test 2 300 1")
+          expect(server.commands).to include("increment overflow_test 3 300 1")
+          expect(server.commands).to include("increment overflow_test 4 300 1")
+          expect(server.commands).to include("increment overflow_test 5 300 1")
         end
       end
     end
@@ -619,16 +625,16 @@ describe "Secure without cert verify" do
   it_behaves_like "Instrumental Agent"
 
   it "should be disabled if the system does not allow secure connections but the user specifically requested secure" do
-    Instrumental::Agent.any_instance.stub(:allows_secure?) { false }
+    allow_any_instance_of(Instrumental::Agent).to receive(:allows_secure?).and_return(false)
     agent = Instrumental::Agent.new('test-token', :enabled => true, :secure => true)
-    agent.secure.should  == false
-    agent.enabled.should == false
+    expect(agent.secure).to eq(false)
+    expect(agent.enabled).to eq(false)
   end
 
-it "should be fallback to insecure if the system does not allow secure connections but the user did not specifically request secure" do
-    Instrumental::Agent.any_instance.stub(:allows_secure?) { false }
+  it "should be fallback to insecure if the system does not allow secure connections but the user did not specifically request secure" do
+    allow_any_instance_of(Instrumental::Agent).to receive(:allows_secure?) { false }
     agent = Instrumental::Agent.new('test-token', :enabled => true)
-    agent.secure.should  == false
-    agent.enabled.should == true
+    expect(agent.secure).to eq(false)
+    expect(agent.enabled).to eq(true)
   end
 end

data/spec/spec_helper.rb

@@ -11,6 +11,8 @@ RSpec.configure do |config|
   config.after(:all) do
   end
 
+  config.raise_errors_for_deprecations!
+
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: instrumental_agent
 version: !ruby/object:Gem::Version
-  version: 0.13.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Elijah Miller
@@ -11,8 +11,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -33,14 +47,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
@@ -55,7 +69,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Track anything.
+description: This agent supports Instrumental custom metric monitoring for Ruby applications.
+  It provides high-data reliability at high scale, without ever blocking your process
+  or causing an exception.
 email:
 - support@instrumentalapp.com
 executables: []
@@ -80,13 +96,15 @@ files:
 - lib/instrumental/system_timer.rb
 - lib/instrumental/version.rb
 - lib/instrumental_agent.rb
+- script/setup
+- script/test
 - spec/agent_spec.rb
 - spec/spec_helper.rb
 - spec/test.crt
 - spec/test.csr
 - spec/test.key
 - spec/test_server.rb
-homepage: http://github.com/expectedbehavior/instrumental_agent
+homepage: http://github.com/instrumental/instrumental_agent-ruby
 licenses:
 - MIT
 metadata: {}
@@ -106,10 +124,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Agent for reporting data to instrumentalapp.com
+summary: Custom metric monitoring for Ruby applications via Instrumental
 test_files:
 - spec/agent_spec.rb
 - spec/spec_helper.rb