instrumental_agent 1.0.1 → 2.0.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32d9f3dab94080e4c8194ab8c71e0ddf4d83bb8a
-  data.tar.gz: fa78452258ca2f450d5a6da975a5c1d0a114902a
+  metadata.gz: a89c1b56985adcb54ca4ece8434cdcf03dc4d6e9
+  data.tar.gz: 54781c1980d41308b91e2dab943ce1173a344caa
 SHA512:
-  metadata.gz: 5174c7be573fab85d465dc2a6db07d35a62b7bcae160668fc4182da5fefc795930911392c556fa71af0a210723a5534c8548305f2de74c1ccbaae40d535ae448
-  data.tar.gz: 69d4ad769e79161afa6d0c915c9a2b21835a010fc5452a975cfa438484f61906e4474e366c845ce1f46443b3effeba6b737c2f738dfaadfad9a7441604fc05f6
+  metadata.gz: d7616d931a95c446071b4971518cacea08bfd2227d6c13192158de0d979285586bfae0e752b887484d768a9edcc20ee78fa64ee0e7ce16668f358481c2c30632
+  data.tar.gz: d8f5775a27509c6c958772a7aa80e6d99a9778dda00d5c02a94b5fb4e198ebcbe98bde63b15fb1d36d67dab5051772a0e05b77ec94a46063ee2ca7a9e97cb926

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p648

data/.travis.yml

@@ -1,9 +1,8 @@
 sudo: false
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
-  - jruby-18mode
-  - jruby-19mode
+  - 2.0.0-p648
+  - 2.1.5
+  - 2.2.3
+  - 2.3.0
+  - 2.4.0

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 2.0.0.alpha [August 18, 2017]
+* Add automatic tracking of common application metrics
+
 ### 1.0.1 [July 12, 2016]
 * Make agent initialization threadsafe
 

data/Gemfile

@@ -6,3 +6,6 @@ if RUBY_VERSION < "1.9" && !%w{jruby rbx}.include?(ruby_engine)
   # Built and installed via ext/mkrf_conf.rb
   gem 'system_timer', '~> 1.2'
 end
+
+# fixes 2.3.0 ffi bundle error
+gem 'ffi', '~> 1.0.11'

data/README.md

@@ -2,7 +2,7 @@
 
 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. 
+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
 
@@ -12,10 +12,10 @@ 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 [project API token](https://instrumentalapp.com/docs/tokens).
 
 ```ruby
-I = Instrumental::Agent.new('YOUR_API_KEY', :enabled => Rails.env.production?)
+I = Instrumental::Agent.new('PROJECT_API_TOKEN', :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.
@@ -59,14 +59,9 @@ User.find_each do |user|
 end
 ```
 
-## Server Stats
+## Server Metrics
 
-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
-instrument_server
-```
+Want server stats like load, memory, etc.? Check out [InstrumentalD](https://github.com/instrumental/instrumentald).
 
 ## Agent Control
 
@@ -99,6 +94,20 @@ If you plan on tracking metrics in Resque jobs, you will need to explicitly clea
 
 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.
 
+## Automated Metric Collection
+
+v2.x+ of the Instrumental Agent introduced automated metric collection for your application by way of the [Metrician gem](https://github.com/Instrumental/metrician-ruby). You can read more about the metrics it collects in the [Instrumental documentation](https://instrumentalapp.com/docs/metrician/installation).
+
+### Upgrading from 1.x
+
+If you are upgrading from the pre-2.x version of instrumental and **do not** want automated metric collection, you can disable it by setting the following in your agent setup:
+
+```
+I = Instrumental::Agent.new('PROJECT_API_TOKEN',
+  :enabled => Rails.env.production?,
+  :metrician => false
+)
+```
 
 ## Troubleshooting & Help
 

data/instrumental_agent.gemspec

@@ -10,14 +10,18 @@ Gem::Specification.new do |s|
   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"
-
+  s.required_ruby_version = '>= 2.0.0'
 
   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("metrician", [">= 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"])
+  s.add_development_dependency("timecop", [">= 0"])
 end

data/lib/instrumental/agent.rb

@@ -5,6 +5,7 @@ require 'openssl' rescue nil
 require 'resolv'
 require 'thread'
 require 'socket'
+require 'metrician'
 
 
 module Instrumental
@@ -77,10 +78,15 @@ module Instrumental
       @certs           = certificates
       @dns_resolutions = 0
       @last_connect_at = 0
+      @metrician       = options[:metrician].nil? ? true : !!options[:metrician]
       @start_worker_mutex = Mutex.new
       @queue = Queue.new
 
       setup_cleanup_at_exit if @enabled
+
+      if @metrician
+        Metrician.activate(self)
+      end
     end
 
     # Store a gauge for a metric, optionally at a specific time.
@@ -473,6 +479,7 @@ module Instrumental
         # or we cannot reach the server
         # or the connection state of this socket is in a race
         logger.error "unable to connect to Instrumental, hanging up with #{@queue.size} messages remaining"
+        logger.debug "Exception: #{err.inspect}\n#{err.backtrace.join("\n")}"
         allow_reconnect = false
       else
         report_exception(err)

data/lib/instrumental/version.rb

@@ -1,3 +1,3 @@
 module Instrumental
-  VERSION = "1.0.1"
+  VERSION = "2.0.0.alpha"
 end

data/script/setup

@@ -2,7 +2,25 @@
 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
+rbenv which ruby >/dev/null 2>&1 || (brew upgrade ruby-build || true; rbenv install)
+
+# Setup rbenv so we can switch rubies below
+eval "$(rbenv init - --no-rehash)"
+
+for ruby_version in `ruby -ryaml -e 'puts YAML.load(File.read(".travis.yml"))["rvm"].join(" ")'`; do
+  rbenv versions --bare | grep "^${ruby_version}$" || rbenv install $ruby_version
+  rbenv shell $ruby_version
+
+  gem list -i bundler >/dev/null || gem install bundler
+
+  bundle install
+done
+
+tput bold    # bold text
+tput setaf 2 # green text
+echo "****************************************************************"
+echo "*                                                              *"
+echo "*                         Good to go!                          *"
+echo "*                                                              *"
+echo "****************************************************************"
+tput sgr0    # reset to default text

data/script/test

@@ -2,5 +2,37 @@
 set -e
 cd "$(dirname "$0")/.."
 
-script/setup
-bundle exec rspec
+eval "$(rbenv init - --no-rehash)"
+
+rspec_file_line="$1"
+if [[ "$rspec_file_line" != "" ]]; then
+  rspec_file_line="[${rspec_file_line}]"
+fi
+
+success="true"
+
+for ruby_version in `ruby -ryaml -e 'puts YAML.load(File.read(".travis.yml"))["rvm"].join(" ")'`; do
+  {
+    echo "testing ruby version $ruby_version" &&
+      rbenv shell $ruby_version &&
+      bundle exec rspec
+  } || success="false"
+done
+
+if [ $success == "true" ]; then
+  tput bold    # bold text
+  tput setaf 2 # green text
+  echo "======================================"
+  echo "=              Passed                ="
+  echo "======================================"
+  tput sgr0    # reset to default text
+  exit 0
+else
+  tput bold    # bold text
+  tput setaf 1 # red text
+  echo "======================================"
+  echo "=              FAILED                ="
+  echo "======================================"
+  tput sgr0    # reset to default text
+  exit 1
+fi

data/spec/agent_spec.rb

@@ -1,7 +1,19 @@
 require 'spec_helper'
 
-def wait(n=0.2)
-  sleep n # FIXME: hack
+def wait(n=0.2, &block)
+  start = Time.now
+  if block_given?
+    begin
+      yield
+    rescue Exception => ex
+      if (Time.now - start) < 5
+        sleep n
+        retry
+      end
+    end
+  else
+    sleep n
+  end
 end
 
 FORK_SUPPORTED = begin
@@ -24,7 +36,8 @@ shared_examples "Instrumental Agent" do
     let(:synchronous)  { false }
     let(:token)        { 'test_token' }
     let(:address)      { server.host_and_port }
-    let(:agent)        { Instrumental::Agent.new(token, :collector => address, :synchronous => synchronous, :enabled => enabled, :secure => secure?, :verify_cert => verify_cert?) }
+    let(:metrician)    { false }
+    let(:agent)        { Instrumental::Agent.new(token, :collector => address, :synchronous => synchronous, :enabled => enabled, :secure => secure?, :verify_cert => verify_cert?, :metrician => metrician) }
 
     # Server options
     let(:listen)       { true }
@@ -52,31 +65,36 @@ shared_examples "Instrumental Agent" do
 
       it "should not connect to the server after receiving a metric" do
         agent.gauge('disabled_test', 1)
-        wait
-        expect(server.connect_count).to eq(0)
+        wait do
+          expect(server.connect_count).to eq(0)
+        end
       end
 
       it "should no op on flush without reconnect" do
         1.upto(100) { agent.gauge('disabled_test', 1) }
         agent.flush(false)
-        wait
-        expect(server.commands).to be_empty
+        wait do
+          expect(server.commands).to be_empty
+        end
       end
 
       it "should no op on flush with reconnect" do
         1.upto(100) { agent.gauge('disabled_test', 1) }
         agent.flush(true)
-        wait
-        expect(server.commands).to be_empty
+        wait do
+          expect(server.commands).to be_empty
+        end
       end
 
       it "should no op on an empty flush" do
         agent.flush(true)
-        wait
-        expect(server.commands).to be_empty
+        wait do
+          expect(server.commands).to be_empty
+        end
       end
 
       it "should send metrics to logger" do
+        Timecop.freeze
         now = Time.now
         expect(agent.logger).to receive(:debug).with("gauge metric 1 #{now.to_i} 1")
         agent.gauge("metric", 1)
@@ -91,14 +109,16 @@ shared_examples "Instrumental Agent" do
 
       it "should connect to the server after sending a metric" do
         agent.increment("test.foo")
-        wait
-        expect(server.connect_count).to eq(1)
+        wait do
+          expect(server.connect_count).to eq(1)
+        end
       end
 
       it "should announce itself, and include version" do
         agent.increment("test.foo")
-        wait
-        expect(server.commands[0]).to match(/hello .*/)
+        wait do
+          expect(server.commands[0]).to match(/hello .*/)
+        end
         expect(server.commands[0]).to match(/ version /)
         expect(server.commands[0]).to match(/ hostname /)
         expect(server.commands[0]).to match(/ pid /)
@@ -108,15 +128,18 @@ shared_examples "Instrumental Agent" do
 
       it "should authenticate using the token" do
         agent.increment("test.foo")
-        wait
-        expect(server.commands[1]).to eq("authenticate test_token")
+        wait do
+          expect(server.commands[1]).to eq("authenticate test_token")
+        end
       end
 
       it "should report a gauge" do
+        Timecop.freeze
         now = Time.now
         agent.gauge('gauge_test', 123)
-        wait
-        expect(server.commands.last).to eq("gauge gauge_test 123 #{now.to_i} 1")
+        wait do
+          expect(server.commands.last).to eq("gauge gauge_test 123 #{now.to_i} 1")
+        end
       end
 
       it "should report a time as gauge and return the block result" do
@@ -125,8 +148,9 @@ shared_examples "Instrumental Agent" do
           1 + 1
         end
         expect(return_value).to eq(2)
-        wait
-        expect(server.commands.last).to match(/gauge time_value_test .* #{now.to_i}/)
+        wait do
+          expect(server.commands.last).to match(/gauge time_value_test .* #{now.to_i}/)
+        end
       end
 
       it "should report a time_ms as gauge and return the block result" do
@@ -136,8 +160,9 @@ shared_examples "Instrumental Agent" do
           1 + 1
         end
         expect(return_value).to eq(2)
-        wait
-        expect(server.commands.last).to match(/gauge time_value_test 1000/)
+        wait do
+          expect(server.commands.last).to match(/gauge time_value_test 1000/)
+        end
       end
 
       it "should return the value gauged" do
@@ -147,21 +172,24 @@ shared_examples "Instrumental Agent" do
 
       it "should report a gauge with a set time" do
         agent.gauge('gauge_test', 123, 555)
-        wait
-        expect(server.commands.last).to eq("gauge gauge_test 123 555 1")
+        wait do
+          expect(server.commands.last).to eq("gauge gauge_test 123 555 1")
+        end
       end
 
       it "should report a gauge with a set time and count" do
         agent.gauge('gauge_test', 123, 555, 111)
-        wait
-        expect(server.commands.last).to eq("gauge gauge_test 123 555 111")
+        wait do
+          expect(server.commands.last).to eq("gauge gauge_test 123 555 111")
+        end
       end
 
       it "should report an increment" do
         now = Time.now
         agent.increment("increment_test")
-        wait
-        expect(server.commands.last).to eq("increment increment_test 1 #{now.to_i} 1")
+        wait do
+          expect(server.commands.last).to eq("increment increment_test 1 #{now.to_i} 1")
+        end
       end
 
       it "should return the value incremented by" do
@@ -172,33 +200,43 @@ shared_examples "Instrumental Agent" do
       it "should report an increment a value" do
         now = Time.now
         agent.increment("increment_test", 2)
-        wait
-        expect(server.commands.last).to eq("increment increment_test 2 #{now.to_i} 1")
+        wait do
+          expect(server.commands.last).to eq("increment increment_test 2 #{now.to_i} 1")
+        end
       end
 
       it "should report an increment with a set time" do
         agent.increment('increment_test', 1, 555)
-        wait
-        expect(server.commands.last).to eq("increment increment_test 1 555 1")
+        wait do
+          expect(server.commands.last).to eq("increment increment_test 1 555 1")
+        end
       end
 
       it "should report an increment with a set time and count" do
         agent.increment('increment_test', 1, 555, 111)
-        wait
-        expect(server.commands.last).to eq("increment increment_test 1 555 111")
+        wait do
+          expect(server.commands.last).to eq("increment increment_test 1 555 111")
+        end
       end
 
-      it "should discard data that overflows the buffer" do
-        with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
-          5.times do |i|
-            agent.increment('overflow_test', i + 1, 300)
+      context do
+        let(:listen) { false }
+        it "should discard data that overflows the buffer" do
+          with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
+            allow(agent.logger).to receive(:debug)
+            expect(agent.logger).to receive(:debug).with("Dropping command, queue full(3): increment overflow_test 4 300 1")
+            expect(agent.logger).to receive(:debug).with("Dropping command, queue full(3): increment overflow_test 5 300 1")
+            5.times do |i|
+              agent.increment('overflow_test', i + 1, 300)
+            end
+            wait do
+              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
-          wait
-          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
 
@@ -257,8 +295,9 @@ shared_examples "Instrumental Agent" do
       it "should never let an exception reach the user" do
         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)
+        wait do
+          expect(agent.increment('throws_exception', 234)).to eq(nil)
+        end
       end
 
       it "should let exceptions in time bubble up" do
@@ -276,8 +315,9 @@ shared_examples "Instrumental Agent" do
       it "should track invalid metrics" do
         expect(agent.logger).to receive(:warn).with(/%%/)
         agent.increment(' %% .!#@$%^&*', 1, 1)
-        wait
-        expect(server.commands.join("\n")).to include("increment agent.invalid_metric")
+        wait do
+          expect(server.commands.join("\n")).to include("increment agent.invalid_metric")
+        end
       end
 
       it "should allow reasonable metric names" do
@@ -285,15 +325,17 @@ shared_examples "Instrumental Agent" do
         agent.increment('a.b')
         agent.increment('hello.world')
         agent.increment('ThisIsATest.Of.The.Emergency.Broadcast.System.12345')
-        wait
-        expect(server.commands.join("\n")).to_not include("increment agent.invalid_metric")
+        wait do
+          expect(server.commands.join("\n")).to_not include("increment agent.invalid_metric")
+        end
       end
 
       it "should track invalid values" do
         expect(agent.logger).to receive(:warn).with(/hello.*testington/)
         agent.increment('testington', 'hello')
-        wait
-        expect(server.commands.join("\n")).to include("increment agent.invalid_value")
+        wait do
+          expect(server.commands.join("\n")).to include("increment agent.invalid_value")
+        end
       end
 
       it "should allow reasonable values" do
@@ -305,31 +347,51 @@ shared_examples "Instrumental Agent" do
         agent.increment('a',  2.2)
         agent.increment('a',  333.333)
         agent.increment('a',  Float::EPSILON)
-        wait
-        expect(server.commands.join("\n")).to_not include("increment agent.invalid_value")
+        wait do
+          expect(server.commands.join("\n")).to_not include("increment agent.invalid_value")
+        end
       end
 
       it "should send notices to the server" do
+        Timecop.freeze
         tm = Time.now
         agent.notice("Test note", tm)
-        wait
-        expect(server.commands.join("\n")).to include("notice #{tm.to_i} 0 Test note")
+        wait do
+          expect(server.commands.join("\n")).to include("notice #{tm.to_i} 0 Test note")
+        end
       end
 
       it "should prevent a note w/ newline characters from being sent to the server" do
-        expect(agent.notice("Test note\n")).to eq(nil)
-        wait
-        expect(server.commands.join("\n")).to_not include("notice Test note")
+        expect(agent.notice("Test_bad_note\n")).to eq(nil)
+
+        # Send a note that make it through so we're sure the bad note would have
+        # arrived if it was going to.
+        Timecop.freeze
+        tm = Time.now
+        agent.notice("Test_good_note", tm)
+        wait do
+          expect(server.commands.join("\n")).to include("Test_good_note")
+        end
+
+        expect(server.commands.join("\n")).to_not include("Test_bad_note")
       end
 
       it "should allow outgoing metrics to be stopped" do
         tm = Time.now
         agent.increment("foo.bar", 1, tm)
         agent.stop
+
+        # In Java the test server hangs sometimes when the agent disconnects so
+        # this cleans up the server.
+        server.stop
         wait
-        agent.increment("foo.baz", 1, tm)
+        server.listen
+
         wait
-        expect(server.commands.join("\n")).to include("increment foo.baz 1 #{tm.to_i}")
+        agent.increment("foo.baz", 1, tm)
+        wait do
+          expect(server.commands.join("\n")).to include("increment foo.baz 1 #{tm.to_i}")
+        end
         expect(server.commands.join("\n")).to_not include("increment foo.bar 1 #{tm.to_i}")
       end
 
@@ -338,28 +400,33 @@ shared_examples "Instrumental Agent" do
         expect(agent.instance_variable_get(:@queue).size).to be > 0
         agent.flush
         expect(agent.instance_variable_get(:@queue).size).to eq(0)
-        wait
-        expect(server.commands.grep(/^gauge a /).size).to eq(100)
+        wait do
+          expect(server.commands.grep(/^gauge a /).size).to eq(100)
+        end
       end
 
       it "should no op on an empty flush" do
         agent.flush(true)
-        wait
-        expect(server.commands).to be_empty
+        wait do
+          expect(server.commands).to be_empty
+        end
       end
     end
 
     describe Instrumental::Agent, "connection problems" do
       it "should automatically reconnect on disconnect" do
-        agent.increment("reconnect_test", 1, 1234)
-        wait
+        agent.increment("reconnect_test1", 1, 1234)
+        wait do
+          expect(server.commands.grep(/reconnect_test1/).size).to eq(1)
+        end
         server.disconnect_all
         wait(1)
         agent.increment('reconnect_test', 1, 5678) # triggers reconnect
-        wait(1)
-        expect(server.connect_count).to eq(2)
-        # Ensure the last command sent has been received after the reconnect attempt
-        expect(server.commands.last).to eq("increment reconnect_test 1 5678 1")
+        wait do
+          expect(server.connect_count).to eq(2)
+          # Ensure the last command sent has been received after the reconnect attempt
+          expect(server.commands.last).to eq("increment reconnect_test 1 5678 1")
+        end
       end
 
       context 'not listening' do
@@ -413,43 +480,48 @@ shared_examples "Instrumental Agent" do
         it "should cancel the worker thread when the host has hung up" do
           # Start the background agent thread and let it send one metric successfully
           agent.gauge('connection_failure', 1, 1234)
-          wait
+          wait do
+            expect(server.commands.grep(/connection_failure/).size).to eq(1)
+          end
           # Stop the server
           server.stop
           wait
           # Send one metric to the stopped server
           agent.gauge('connection_failure', 1, 1234)
-          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
-          expect(agent.send(:running?)).to eq(false)
+          wait do
+            expect(agent.send(:running?)).to eq(false)
+          end
           expect(agent.queue.size).to eq(1)
         end
 
         it "should restart the worker thread after hanging it up during an unreachable host event" do
           # Start the background agent thread and let it send one metric successfully
           agent.gauge('connection_failure', 1, 1234)
-          wait
+          wait do
+            expect(server.commands.grep(/connection_failure/).size).to eq(1)
+          end
           # Stop the server
           server.stop
           wait
           # Send one metric to the stopped server
           agent.gauge('connection_failure', 1, 1234)
-          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
-          expect(agent.send(:running?)).to eq(false)
+          wait do
+            expect(agent.send(:running?)).to eq(false)
+          end
           expect(agent.queue.size).to eq(1)
-          wait
           # Start the server back up again
           server.listen
-          wait
           # Sending another metric should kickstart the background worker thread
           agent.gauge('connection_failure', 1, 1234)
-          wait
           # The agent should now be running the background thread, and the queue should be empty
-          expect(agent.send(:running?)).to eq(true)
-          expect(agent.queue.size).to eq(0)
+          wait do
+            expect(agent.send(:running?)).to eq(true)
+            expect(agent.queue.size).to eq(0)
+          end
         end
 
       end
@@ -512,11 +584,19 @@ 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
+        wait do
+          expect(server.commands.grep(/foo/).size).to eq(1)
+        end
         expect(agent).to receive(:flush_socket) do
           r, w = IO.pipe
-          Thread.new do
-            IO.select([r]) # mimic an endless blocking select poll
+          Thread.new do # JRuby requires extra thread here according to e9bb707e
+            begin
+              IO.select([r]) # mimic an endless blocking select poll
+            rescue Object => ex
+              # This rescue-raise prevents JRuby from printing a backtrace at
+              # the end of the run complaining about an exception in this thread.
+              raise
+            end
           end.join
         end
         with_constants('Instrumental::Agent::EXIT_FLUSH_TIMEOUT' => 3) do
@@ -629,6 +709,32 @@ shared_examples "Instrumental Agent" do
         end
       end
     end
+
+    describe Instrumental::Agent, "metrician" do
+      context "enabled" do
+        let(:metrician) { true }
+
+        it "is enabled by default" do
+          a = agent
+          expect(Metrician.agent).to eq(a)
+        end
+
+        it "uses agent logger" do
+          new_logger = double
+          agent.logger = new_logger
+          expect(Metrician.logger).to eq(new_logger)
+        end
+      end
+
+      context "disabled" do
+        let(:metrician) { false }
+
+        it "can be disbaled" do
+          expect(Metrician).to_not receive(:activate)
+          agent = Instrumental::Agent.new('test-token', :metrician => false)
+        end
+      end
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 $: << File.join(File.dirname(__FILE__), "..", "lib")
 
-require 'instrumental_agent'
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default, :development)
+
 require 'test_server'
 
 RSpec.configure do |config|
@@ -8,6 +11,10 @@ RSpec.configure do |config|
   config.before(:all) do
   end
 
+  config.before(:each) do
+    Timecop.return
+  end
+
   config.after(:all) do
   end
 

data/spec/test_server.rb

@@ -77,15 +77,14 @@ class TestServer
         end
       rescue Exception => err
         unless @stopping
-          puts "EXCEPTION:", err unless @stopping
+          puts "EXCEPTION:", err.inspect, err.backtrace.join("\n")
           retry
         end
       end
     end
     # puts "server up"
   rescue Errno::EADDRINUSE => err
-    puts "#{err.inspect} failed to get port #{@port}"
-    puts err.message
+    puts "#{err.inspect} failed to get port #{@port}", err.message
     @port += 1
     retry
   end
@@ -97,7 +96,10 @@ class TestServer
   def stop
     @stopping = true
     disconnect_all
-    @main_thread.kill if @main_thread
+    if @main_thread
+      @main_thread.kill
+      @main_thread.join # wait for thread to die
+    end
     @main_thread = nil
     @client_threads.each { |thread| thread.kill }
     @client_threads = []
@@ -105,6 +107,8 @@ class TestServer
       @server.close if @server
     rescue Exception => e
     end
+    @server = nil
+    @stopping = false
   end
 
   def fd_for_socket(socket)
@@ -130,8 +134,11 @@ class TestServer
         c.flush
         c.close
       rescue Exception => e
-        puts e.message
-        puts e.backtrace.join("\n")
+        unless @stopping
+          puts "Error in TestServer#disconnect_all"
+          puts e.inspect
+          puts e.backtrace.join("\n")
+        end
       end
     }
     @connections = []

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: instrumental_agent
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0.alpha
 platform: ruby
 authors:
 - Elijah Miller
@@ -11,62 +11,90 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-12 00:00:00.000000000 Z
+date: 2017-08-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: metrician
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: 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
     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: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: This agent supports Instrumental custom metric monitoring for Ruby applications.
@@ -78,9 +106,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
+- .gitignore
+- .rspec
+- .ruby-version
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -114,17 +143,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: Custom metric monitoring for Ruby applications via Instrumental