instrumental_agent 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68d5c4451d15ba2eeb83f189d14f4a34c6ec77fd
-  data.tar.gz: 6e7e2fd6ec37a5eb210563deec7c04ee91794a84
+  metadata.gz: d22dc8e7673c5701cf1cdc654ebd8b953eff28c7
+  data.tar.gz: 53fa9eb53ace63abe3a243b3ce8397bf3d53f01f
 SHA512:
-  metadata.gz: 7973eec6253fe0e536480351318746c2ab6561a272485d39297b13e4cc50fdda98dd32fd538baf22c7eac9128ba61cb64982b0c221002155bf14a77862d04ede
-  data.tar.gz: c1979ec7dcc1f04c3c5d4aaad1debf8d6ffecaa87ee2e527332e3fda2d96904db701f2f5c922897f09ed841775c3c84233682edb18c101b963553aeaba5c42e7
+  metadata.gz: bc8ec3269967f078690443c315c0dfe1d450603855b2f9cb31a01f3625cb00642cb1e5975cfdc7b3ee25c04c9f4b5249f4c1d5b1aa8fc7e0fed5086fb5f9fc49
+  data.tar.gz: 3c846c8a723c0c5e9b5c1998a78d330caad7a7b67e663ebb8a5abd21e8866348af0538ef14149b7bd897190930703e9e2c990cb5168caa9fa929941354f762ea

data/.travis.yml

@@ -1,4 +1,3 @@
-sudo: false
 language: ruby
 rvm:
   - 1.8.7
@@ -7,3 +6,5 @@ rvm:
   - 2.0.0
   - jruby-18mode
   - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.13.1 [August 3, 2015]
+* Revert encrypted support
+
 ### 0.13.0 [August 3, 2015]
 * Add support for encrypted transport, tests for same
 

data/Gemfile

@@ -1,8 +1,8 @@
 source "https://rubygems.org"
 
 gemspec
-ruby_engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-if RUBY_VERSION < "1.9" && !%w{jruby rbx}.include?(ruby_engine)
+
+if RUBY_VERSION < "1.9"
   # Built and installed via ext/mkrf_conf.rb
   gem 'system_timer', '~> 1.2'
 end

data/Rakefile

@@ -1,4 +1,3 @@
-require 'bundler/setup'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/instrumental_agent.gemspec

@@ -19,4 +19,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<rake>, [">= 0"])
   s.add_development_dependency(%q<rspec>, ["~> 2.0"])
   s.add_development_dependency(%q<fuubar>, [">= 0"])
+  if RUBY_VERSION >= "1.9.2"
+    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/lib/instrumental/agent.rb

@@ -1,24 +1,22 @@
 require 'instrumental/version'
 require 'instrumental/system_timer'
 require 'logger'
-require 'openssl' rescue nil
 require 'thread'
 require 'socket'
 
 
 module Instrumental
   class Agent
-    BACKOFF             = 2.0
-    CONNECT_TIMEOUT     = 20
-    EXIT_FLUSH_TIMEOUT  = 5
-    HOSTNAME            = Socket.gethostbyname(Socket.gethostname).first rescue Socket.gethostname
-    MAX_BUFFER          = 5000
+    BACKOFF = 2.0
     MAX_RECONNECT_DELAY = 15
-    REPLY_TIMEOUT       = 10
-
+    MAX_BUFFER = 5000
+    REPLY_TIMEOUT = 10
+    CONNECT_TIMEOUT = 20
+    EXIT_FLUSH_TIMEOUT = 5
+    HOSTNAME = Socket.gethostbyname(Socket.gethostname).first rescue Socket.gethostname
 
     attr_accessor :host, :port, :synchronous, :queue
-    attr_reader :connection, :enabled, :secure
+    attr_reader :connection, :enabled
 
     def self.logger=(l)
       @logger = l
@@ -44,33 +42,18 @@ module Instrumental
 
       # defaults
       # host:        collector.instrumentalapp.com
-      # port:        8001
+      # port:        8000
       # enabled:     true
       # synchronous: false
-      # secure:      true
-      # verify:      true
       @api_key         = api_key
       @host, @port     = options[:collector].to_s.split(':')
       @host          ||= 'collector.instrumentalapp.com'
-      requested_secure = options[:secure] == true
-      desired_secure   = options[:secure].nil? ? allows_secure? : !!options[:secure]
-      if !allows_secure? && desired_secure
-        logger.warn "Cannot connect to Instrumental via encrypted transport, SSL not available"
-        if requested_secure
-          options[:enabled] = false
-          logger.error "You requested secure protocol to connect to Instrumental, but it is not available on this system (OpenSSL is not defined). Connecting to Instrumental has been disabled."
-        end
-        desired_secure = false
-      end
-      @secure          = desired_secure
-      @verify_cert     = options[:verify_cert].nil? ? true : !!options[:verify_cert]
-      default_port     = @secure ? 8001 : 8000
-      @port            = (@port || default_port).to_i
+      @port            = (@port || 8000).to_i
       @enabled         = options.has_key?(:enabled) ? !!options[:enabled] : true
       @synchronous     = !!options[:synchronous]
       @pid             = Process.pid
       @allow_reconnect = true
-      @certs           = certificates
+
       setup_cleanup_at_exit if @enabled
     end
 
@@ -308,41 +291,10 @@ module Instrumental
       message
     end
 
-    def wait_exceptions
-      classes = [Errno::EAGAIN]
-      if defined?(IO::EAGAINWaitReadable)
-        classes << IO::EAGAINWaitReadable
-      end
-      if defined?(IO::EWOULDBLOCKWaitReadable)
-        classes << IO::EWOULDBLOCKWaitReadable
-      end
-      if defined?(IO::WaitReadable)
-        classes << IO::WaitReadable
-      end
-      classes
-    end
-
-
     def test_connection
       begin
-        # In the case where the socket is an OpenSSL::SSL::SSLSocket,
-        # on Ruby 1.8.6, 1.8.7 or 1.9.1, read_nonblock does not exist,
-        # and so the case of testing socket liveliness via a nonblocking
-        # read that catches a wait condition won't work.
-        #
-        # We grab the SSL socket's underlying IO object and perform the
-        # non blocking read there in order to ensure the socket is still
-        # valid
-        if @socket.respond_to?(:read_nonblock)
-          @socket.read_nonblock(1)
-        elsif @socket.respond_to?(:io)
-          # The SSL Socket may send down additional data at close time,
-          # so we perform two nonblocking reads, one to pull any pending
-          # data on the socket, and the second to actually perform the connection
-          # liveliness test
-          @socket.io.read_nonblock(1024) && @socket.io.read_nonblock(1024)
-        end
-      rescue *wait_exceptions
+        @socket.read_nonblock(1)
+      rescue Errno::EAGAIN
         # noop
       end
     end
@@ -371,29 +323,15 @@ module Instrumental
       end
     end
 
-    def open_socket(remote_host, remote_port, secure, verify_cert)
-      sock = TCPSocket.open(remote_host, remote_port)
-      if secure
-        context = OpenSSL::SSL::SSLContext.new()
-        if verify_cert
-          context.set_params(:verify_mode => OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT)
-        else
-          context.set_params(:verify_mode => OpenSSL::SSL::VERIFY_NONE)
-        end
-        ssl_socket = OpenSSL::SSL::SSLSocket.new(sock, context)
-        ssl_socket.sync_close = true
-        ssl_socket.connect
-        sock = ssl_socket
-      end
-      sock
-    end
+
 
     def run_worker_loop
       command_and_args = nil
       command_options = nil
       logger.info "connecting to collector"
+      @socket = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM, 0)
       with_timeout(CONNECT_TIMEOUT) do
-        @socket = open_socket(host, port, @secure, @verify_cert)
+        @socket.connect Socket.pack_sockaddr_in(port, ipv4_address_for_host(host, port))
       end
       logger.info "connected to collector at #{host}:#{port}"
       hello_options = {
@@ -466,17 +404,11 @@ module Instrumental
       !@thread.nil? && @pid == Process.pid
     end
 
-    def flush_socket(socket)
-      socket.flush
-    end
-
     def disconnect
       if connected?
         logger.info "Disconnecting..."
         begin
-          with_timeout(EXIT_FLUSH_TIMEOUT) do
-            flush_socket(@socket)
-          end
+          with_timeout(EXIT_FLUSH_TIMEOUT) { @socket.flush }
         rescue Timeout::Error
           logger.info "Timed out flushing socket..."
         end
@@ -485,21 +417,6 @@ module Instrumental
       @socket = nil
     end
 
-    def allows_secure?
-      defined?(OpenSSL)
-    end
-
-    def certificates
-      if allows_secure?
-        base_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
-        %w{equifax geotrust rapidssl}.map do |name|
-          OpenSSL::X509::Certificate.new(File.open(File.join(base_dir, "certs", "#{name}.ca.pem")))
-        end
-      else
-        []
-      end
-    end
-
   end
 
 end

data/lib/instrumental/version.rb

@@ -1,3 +1,3 @@
 module Instrumental
-  VERSION = "0.13.0"
+  VERSION = "0.13.1"
 end

data/spec/agent_spec.rb

@@ -1,485 +1,460 @@
 require 'spec_helper'
 
-def wait(n=0.2)
-  sleep n # FIXME: hack
+def wait
+  sleep 0.2 # FIXME: hack
 end
 
-FORK_SUPPORTED = begin
-                   Process.wait(fork { true })
-                   true
-                 rescue Exception => e
-                   false
-                 end
+describe Instrumental::Agent, "disabled" do
+  before do
+    Instrumental::Agent.logger.level = Logger::UNKNOWN
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :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
 
-shared_examples "Instrumental Agent" do
-  context do
+  it "should not connect to the server after receiving a metric" do
+    wait
+    @agent.gauge('disabled_test', 1)
+    wait
+    @server.connect_count.should == 0
+  end
 
-    # Inferred:
-    # secure? and verify_cert? are set
+  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
+  end
 
-    # Agent options
-    let(:enabled)      { true }
-    let(:synchronous)  { false }
-    let(:token)        { 'test_token' }
-    let(:agent)        { Instrumental::Agent.new(token, :collector => server.host_and_port, :synchronous => synchronous, :enabled => enabled, :secure => secure?, :verify_cert => verify_cert?) }
+  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
+  end
 
-    # Server options
-    let(:listen)       { true }
-    let(:response)     { true }
-    let(:authenticate) { true }
-    let(:server)       { TestServer.new(:listen => listen, :authenticate => authenticate, :response => response, :secure => secure?) }
+  it "should no op on an empty flush" do
+    @agent.flush(true)
+    wait
+    @server.commands.should be_empty
+  end
 
-    before do
-      Instrumental::Agent.logger.level = Logger::UNKNOWN
-      @server = server
-      wait
-    end
+  it "should send metrics to logger" do
+    now = Time.now
+    @agent.logger.should_receive(:debug).with("gauge metric 1 #{now.to_i} 1")
+    @agent.gauge("metric", 1)
+  end
+end
 
-    after do
-      agent.stop
-      server.stop
-    end
+describe Instrumental::Agent, "enabled" do
+  before do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+  end
 
-    describe Instrumental::Agent, "disabled" do
-      let(:enabled) { false }
+  after do
+    @agent.stop
+    @agent = nil
+    @server.stop
+  end
 
-      it "should not connect to the server" do
-        server.connect_count.should == 0
-      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
-        agent.gauge('disabled_test', 1)
-        wait
-        server.connect_count.should == 0
-      end
+  it "should connect to the server after sending a metric" do
+    @agent.increment("test.foo")
+    wait
+    @server.connect_count.should == 1
+  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
-      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 /
+  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
-      end
+  it "should authenticate using the token" do
+    @agent.increment("test.foo")
+    wait
+    @server.commands[1].should == "authenticate test_token"
+  end
 
-      it "should no op on an empty flush" do
-        agent.flush(true)
-        wait
-        server.commands.should be_empty
-      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"
+  end
 
-      it "should send metrics to logger" do
-        now = Time.now
-        agent.logger.should_receive(:debug).with("gauge metric 1 #{now.to_i} 1")
-        agent.gauge("metric", 1)
-      end
-    end
+  it "should report a time as gauge and return the block result" do
+    now = Time.now
+    @agent.time("time_value_test") do
+      1 + 1
+    end.should == 2
+    wait
+    @server.commands.last.should =~ /gauge time_value_test .* #{now.to_i}/
+  end
 
-    describe Instrumental::Agent, "enabled" do
+  it "should return the value gauged" do
+    now = Time.now
+    @agent.gauge('gauge_test', 123).should == 123
+    @agent.gauge('gauge_test', 989).should == 989
+    wait
+  end
 
-      it "should not connect to the server" do
-        server.connect_count.should == 0
-      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"
+  end
 
-      it "should connect to the server after sending a metric" do
-        agent.increment("test.foo")
-        wait
-        server.connect_count.should == 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"
+  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 /
-      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"
+  end
 
-      it "should authenticate using the token" do
-        agent.increment("test.foo")
-        wait
-        server.commands[1].should == "authenticate test_token"
-      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
+    wait
+  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"
-      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"
+  end
 
-      it "should report a time as gauge and return the block result" do
-        now = Time.now
-        agent.time("time_value_test") do
-          1 + 1
-        end.should == 2
-        wait
-        server.commands.last.should =~ /gauge time_value_test .* #{now.to_i}/
-      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"
+  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
-        wait
-      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"
+  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"
+  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)
       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")
+    end
+  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"
-      end
+  it "should send all data in synchronous mode" do
+    with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
+      @agent.synchronous = true
+      5.times do |i|
+        @agent.increment('overflow_test', i + 1, 300)
+      end
+      @agent.instance_variable_get(:@queue).size.should == 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")
+    end
+  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"
-      end
+  it "should automatically reconnect when forked" do
+    wait
+    @agent.increment('fork_reconnect_test', 1, 2)
+    fork do
+      @agent.increment('fork_reconnect_test', 1, 3) # triggers reconnect
+    end
+    wait
+    @agent.increment('fork_reconnect_test', 1, 4) # triggers reconnect
+    wait
+    @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")
+  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
-        wait
-      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
+    wait
+  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"
-      end
+  it "should let exceptions in time bubble up" do
+    expect { @agent.time('za') { raise "fail" } }.to raise_error
+  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"
-      end
+  it "should return nil if the user overflows the MAX_BUFFER" do
+    1.upto(Instrumental::Agent::MAX_BUFFER) do
+      @agent.increment("test").should == 1
+      thread = @agent.instance_variable_get(:@thread)
+      thread.kill
+    end
+    @agent.increment("test").should be_nil
+  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"
-      end
+  it "should track invalid metrics" do
+    @agent.logger.should_receive(:warn).with(/%%/)
+    @agent.increment(' %% .!#@$%^&*', 1, 1)
+    wait
+    @server.commands.join("\n").should include("increment agent.invalid_metric")
+  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)
-          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")
-        end
-      end
+  it "should allow reasonable metric names" do
+    @agent.increment('a')
+    @agent.increment('a.b')
+    @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")
+  end
 
-      it "should send all data in synchronous mode" do
-        with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
-          agent.synchronous = true
-          5.times do |i|
-            agent.increment('overflow_test', i + 1, 300)
-          end
-          agent.instance_variable_get(:@queue).size.should == 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")
-        end
-      end
+  it "should track invalid values" do
+    @agent.logger.should_receive(:warn).with(/hello.*testington/)
+    @agent.increment('testington', 'hello')
+    wait
+    @server.commands.join("\n").should include("increment agent.invalid_value")
+  end
 
-      if FORK_SUPPORTED
-        it "should automatically reconnect when forked" do
-          agent.increment('fork_reconnect_test', 1, 2)
-          fork do
-            agent.increment('fork_reconnect_test', 1, 3) # triggers reconnect
-          end
-          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")
-        end
-      end
+  it "should allow reasonable values" do
+    @agent.increment('a', -333.333)
+    @agent.increment('a', -2.2)
+    @agent.increment('a', -1)
+    @agent.increment('a',  0)
+    @agent.increment('a',  1)
+    @agent.increment('a',  2.2)
+    @agent.increment('a',  333.333)
+    @agent.increment('a',  Float::EPSILON)
+    wait
+    @server.commands.join("\n").should_not include("increment agent.invalid_value")
+  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
-        wait
-      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")
+  end
 
-      it "should let exceptions in time bubble up" do
-        expect { agent.time('za') { raise "fail" } }.to raise_error
-      end
+  it "should prevent a note w/ newline characters from being sent to the server" do
+    @agent.notice("Test note\n").should be_nil
+    wait
+    @server.commands.join("\n").should_not include("notice Test note")
+  end
 
-      it "should return nil if the user overflows the MAX_BUFFER" do
-        1.upto(Instrumental::Agent::MAX_BUFFER) do
-          agent.increment("test").should == 1
-          thread = agent.instance_variable_get(:@thread)
-          thread.kill
-        end
-        agent.increment("test").should be_nil
-      end
+  it "should allow outgoing metrics to be stopped" do
+    tm = Time.now
+    @agent.increment("foo.bar", 1, tm)
+    @agent.stop
+    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}")
+  end
 
-      it "should track invalid metrics" do
-        agent.logger.should_receive(:warn).with(/%%/)
-        agent.increment(' %% .!#@$%^&*', 1, 1)
-        wait
-        server.commands.join("\n").should include("increment agent.invalid_metric")
-      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 >= 100
+    @agent.flush
+    @agent.instance_variable_get(:@queue).size.should ==  0
+    wait
+    @server.commands.grep(/^gauge a /).size.should == 100
+  end
 
-      it "should allow reasonable metric names" do
-        agent.increment('a')
-        agent.increment('a.b')
-        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")
-      end
+  it "should no op on an empty flush" do
+    @agent.flush(true)
+    wait
+    @server.commands.should be_empty
+  end
+end
 
-      it "should track invalid values" do
-        agent.logger.should_receive(:warn).with(/hello.*testington/)
-        agent.increment('testington', 'hello')
-        wait
-        server.commands.join("\n").should include("increment agent.invalid_value")
-      end
+describe Instrumental::Agent, "connection problems" do
+  after do
+    @agent.stop
+    @server.stop
+  end
 
-      it "should allow reasonable values" do
-        agent.increment('a', -333.333)
-        agent.increment('a', -2.2)
-        agent.increment('a', -1)
-        agent.increment('a',  0)
-        agent.increment('a',  1)
-        agent.increment('a',  2.2)
-        agent.increment('a',  333.333)
-        agent.increment('a',  Float::EPSILON)
-        wait
-        server.commands.join("\n").should_not include("increment agent.invalid_value")
-      end
+  it "should automatically reconnect on disconnect" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    @agent.increment("reconnect_test", 1, 1234)
+    wait
+    @server.disconnect_all
+    wait
+    @agent.increment('reconnect_test', 1, 5678) # triggers reconnect
+    wait
+    @server.connect_count.should == 2
+    @server.commands.last.should == "increment reconnect_test 1 5678 1"
+  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")
-      end
+  it "should buffer commands when server is down" do
+    @server = TestServer.new(:listen => false)
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    wait
+    @agent.increment('reconnect_test', 1, 1234)
+    wait
+    @agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+  end
 
-      it "should prevent a note w/ newline characters from being sent to the server" do
-        agent.notice("Test note\n").should be_nil
-        wait
-        server.commands.join("\n").should_not include("notice Test note")
-      end
+  it "should buffer commands when server is not responsive" do
+    @server = TestServer.new(:response => false)
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    wait
+    @agent.increment('reconnect_test', 1, 1234)
+    wait
+    @agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+  end
 
-      it "should allow outgoing metrics to be stopped" do
-        tm = Time.now
-        agent.increment("foo.bar", 1, tm)
-        agent.stop
-        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}")
-      end
+  it "should buffer commands when authentication fails" do
+    @server = TestServer.new(:authenticate => false)
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    wait
+    @agent.increment('reconnect_test', 1, 1234)
+    wait
+    @agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
+  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
-        agent.flush
-        agent.instance_variable_get(:@queue).size.should ==  0
-        wait
-        server.commands.grep(/^gauge a /).size.should == 100
-      end
+  it "should warn once when buffer is full" do
+    with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
+      @server = TestServer.new(:listen => false)
+      @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+      wait
+      @agent.logger.should_receive(:warn).with(/Queue full/).once
 
-      it "should no op on an empty flush" do
-        agent.flush(true)
-        wait
-        server.commands.should be_empty
-      end
+      @agent.increment('buffer_full_warn_test', 1, 1234)
+      @agent.increment('buffer_full_warn_test', 1, 1234)
+      @agent.increment('buffer_full_warn_test', 1, 1234)
+      @agent.increment('buffer_full_warn_test', 1, 1234)
+      @agent.increment('buffer_full_warn_test', 1, 1234)
     end
+  end
 
-    describe Instrumental::Agent, "connection problems" do
-      it "should automatically reconnect on disconnect" do
-        agent.increment("reconnect_test", 1, 1234)
-        wait
-        server.disconnect_all
-        wait(1)
-        agent.increment('reconnect_test', 1, 5678) # triggers reconnect
-        wait(1)
-        server.connect_count.should == 2
-        server.commands.last.should == "increment reconnect_test 1 5678 1"
-      end
-
-      context 'not listening' do
-        let(:listen) { false }
-
-        it "should buffer commands when server is down" do
-          agent.increment('reconnect_test', 1, 1234)
-          wait
-          agent.queue.pop(true).should 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
-
-            agent.increment('buffer_full_warn_test', 1, 1234)
-            agent.increment('buffer_full_warn_test', 1, 1234)
-            agent.increment('buffer_full_warn_test', 1, 1234)
-            agent.increment('buffer_full_warn_test', 1, 1234)
-            agent.increment('buffer_full_warn_test', 1, 1234)
-          end
-        end
-      end
-
-      context 'not responding' do
-        let(:response) { false }
-
-        it "should buffer commands when server is not responsive" do
-          agent.increment('reconnect_test', 1, 1234)
-          wait
-          agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
-        end
-      end
-
-
-      context 'not authenticating' do
-        let(:authenticate) { false }
-
-        it "should buffer commands when authentication fails" do
-          agent.increment('reconnect_test', 1, 1234)
-          wait
-          agent.queue.pop(true).should include("increment reconnect_test 1 1234 1\n")
-        end
-      end
+  it "should send commands in a short-lived process" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    if pid = fork { @agent.increment('foo', 1, 1234) }
+      Process.wait(pid)
+      @server.commands.last.should == "increment foo 1 1234 1"
+    end
+  end
 
-      if FORK_SUPPORTED
-        it "should send commands in a short-lived process" do
-          if pid = fork { agent.increment('foo', 1, 1234) }
-            Process.wait(pid)
-            server.commands.last.should == "increment foo 1 1234 1"
-          end
-        end
-
-        it "should send commands in a process that bypasses at_exit when using #cleanup" do
-          if pid = fork { agent.increment('foo', 1, 1234); agent.cleanup; exit! }
-            Process.wait(pid)
-            server.commands.last.should == "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 }
-          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
-            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 }
-          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
-            end
-          end
-        end
-      end
+  it "should send commands in a process that bypasses at_exit when using #cleanup" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    if pid = fork { @agent.increment('foo', 1, 1234); @agent.cleanup; exit! }
+      Process.wait(pid)
+      @server.commands.last.should == "increment foo 1 1234 1"
+    end
+  end
 
-      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
-          r, w = IO.pipe
-          Thread.new do
-            IO.select([r]) # mimic an endless blocking select poll
-          end.join
-        end
-        with_constants('Instrumental::Agent::EXIT_FLUSH_TIMEOUT' => 3) do
-          tm = Time.now.to_f
-          agent.cleanup
-          diff = Time.now.to_f - tm
-          diff.should <= 3
-        end
+  it "should not wait longer than EXIT_FLUSH_TIMEOUT seconds to exit a process" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    Socket.stub!(:new) { |*args| sleep(5) && StringIO.new }
+    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.should >= 3
+        diff.should < 5
       end
     end
+  end
 
-    describe Instrumental::Agent, "enabled with sync option" do
-      let(:synchronous) { true }
-
-      it "should send all data in synchronous mode" do
-        with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
-          5.times do |i|
-            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")
-        end
+  it "should not wait to exit a process if there are no commands queued" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    Socket.stub!(:new) { |*args| sleep(5) && StringIO.new }
+    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
       end
-
     end
   end
-end
 
-describe "Insecure" do
-  let(:secure?) { false }
-  let(:verify_cert?) { false }
-  it_behaves_like "Instrumental Agent"
+  it "should not wait longer than EXIT_FLUSH_TIMEOUT to attempt flushing the socket when disconnecting" do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => false)
+    @agent.increment('foo', 1)
+    wait
+    @agent.instance_variable_get(:@socket).should_receive(:flush).and_return {
+      r, w = IO.pipe
+      IO.select([r]) # mimic an endless blocking select poll
+    }
+    with_constants('Instrumental::Agent::EXIT_FLUSH_TIMEOUT' => 3) do
+      tm = Time.now.to_f
+      @agent.cleanup
+      diff = Time.now.to_f - tm
+      diff.should <= 3
+    end
+  end
 end
 
-describe "Secure without cert verify" do
-  let(:secure?) { true }
-  let(:verify_cert?) { false }
-  it_behaves_like "Instrumental Agent"
+describe Instrumental::Agent, "enabled with sync option" do
+  before do
+    @server = TestServer.new
+    @agent = Instrumental::Agent.new('test_token', :collector => @server.host_and_port, :synchronous => true)
+  end
 
-  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 }
-    agent = Instrumental::Agent.new('test-token', :enabled => true, :secure => true)
-    agent.secure.should  == false
-    agent.enabled.should == false
+  after do
+    @agent.stop
+    @server.stop
   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 }
-    agent = Instrumental::Agent.new('test-token', :enabled => true)
-    agent.secure.should  == false
-    agent.enabled.should == true
+  it "should send all data in synchronous mode" do
+    with_constants('Instrumental::Agent::MAX_BUFFER' => 3) do
+      5.times do |i|
+        @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")
+    end
   end
+
 end