statsd-ruby 1.1.1 → 1.5.0

data/lib/statsd/monotonic_time.rb

@@ -0,0 +1,35 @@
+class Statsd
+  # = MonotonicTime: a helper for getting monotonic time
+  #
+  # @example
+  #   MonotonicTime.time_in_ms #=> 287138801.144576
+
+  # MonotonicTime guarantees that the time is strictly linearly
+  # increasing (unlike realtime).
+  # @see http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html
+  module MonotonicTime
+    class << self
+      # @return [Integer] current monotonic time in milliseconds
+      def time_in_ms
+        time_in_nanoseconds / (10.0 ** 6)
+      end
+
+      private
+
+      if defined?(Process::CLOCK_MONOTONIC)
+        def time_in_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+      elsif RUBY_ENGINE == 'jruby'
+        def time_in_nanoseconds
+          java.lang.System.nanoTime
+        end
+      else
+        def time_in_nanoseconds
+          t = Time.now
+          t.to_i * (10 ** 9) + t.nsec
+        end
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -1,19 +1,21 @@
 require 'bundler/setup'
-require 'minitest/autorun'
 
 require 'simplecov'
 SimpleCov.start
 
+require 'minitest/autorun'
 require 'statsd'
 require 'logger'
+require 'timeout'
 
 class FakeUDPSocket
   def initialize
     @buffer = []
   end
 
-  def send(message, *rest)
+  def write(message)
     @buffer.push [message]
+    message.length
   end
 
   def recv
@@ -29,6 +31,13 @@ class FakeUDPSocket
   end
 
   def inspect
-    "<FakeUDPSocket: #{@buffer.inspect}>"
+    "<#{self.class.name}: #{@buffer.inspect}>"
+  end
+end
+
+class FakeTCPSocket < FakeUDPSocket
+  alias_method :readline, :recv
+  def write(message)
+    @buffer.push message
   end
 end

data/spec/statsd_admin_spec.rb

@@ -0,0 +1,117 @@
+require 'helper'
+
+describe Statsd::Admin do
+
+  before do
+    class Statsd::Admin
+      o, $VERBOSE = $VERBOSE, nil
+      alias connect_old connect
+      def connect
+        $connect_count ||= 0
+        $connect_count += 1
+      end
+      $VERBOSE = o
+    end
+    @admin = Statsd::Admin.new('localhost', 1234)
+    @socket = @admin.instance_variable_set(:@socket, FakeTCPSocket.new)
+  end
+
+  after do
+    class Statsd::Admin
+      o, $VERBOSE = $VERBOSE, nil
+      alias connect connect_old
+      $VERBOSE = o
+    end
+  end
+
+  describe "#initialize" do
+    it "should set the host and port" do
+      _(@admin.host).must_equal 'localhost'
+      _(@admin.port).must_equal 1234
+    end
+
+    it "should default the host to 127.0.0.1 and port to 8126" do
+      statsd = Statsd::Admin.new
+      _(statsd.host).must_equal '127.0.0.1'
+      _(statsd.port).must_equal 8126
+    end
+  end
+
+  describe "#host and #port" do
+    it "should set host and port" do
+      @admin.host = '1.2.3.4'
+      @admin.port = 5678
+      _(@admin.host).must_equal '1.2.3.4'
+      _(@admin.port).must_equal 5678
+    end
+
+    it "should not resolve hostnames to IPs" do
+      @admin.host = 'localhost'
+      _(@admin.host).must_equal 'localhost'
+    end
+
+    it "should set nil host to default" do
+      @admin.host = nil
+      _(@admin.host).must_equal '127.0.0.1'
+    end
+
+    it "should set nil port to default" do
+      @admin.port = nil
+      _(@admin.port).must_equal 8126
+    end
+  end
+
+  %w(gauges counters timers).each do |action|
+    describe "##{action}" do
+      it "should send a command and return a Hash" do
+        ["{'foo.bar': 0,\n",
+          "'foo.baz': 1,\n",
+          "'foo.quux': 2 }\n",
+          "END\n","\n"].each do |line|
+          @socket.write line
+        end
+        result = @admin.send action.to_sym
+        _(result).must_be_kind_of Hash
+        _(result.size).must_equal 3
+        _(@socket.readline).must_equal "#{action}\n"
+      end
+    end
+
+    describe "#del#{action}" do
+      it "should send a command and return an Array" do
+        ["deleted: foo.bar\n",
+         "deleted: foo.baz\n",
+         "deleted: foo.quux\n",
+          "END\n", "\n"].each do |line|
+          @socket.write line
+        end
+        result = @admin.send "del#{action}", "foo.*"
+        _(result).must_be_kind_of Array
+        _(result.size).must_equal 3
+        _(@socket.readline).must_equal "del#{action} foo.*\n"
+      end
+    end
+  end
+
+  describe "#stats" do
+    it "should send a command and return a Hash" do
+      ["whatever: 0\n", "END\n", "\n"].each do |line| 
+        @socket.write line
+      end
+      result = @admin.stats
+      _(result).must_be_kind_of Hash
+      _(result["whatever"]).must_equal 0
+      _(@socket.readline).must_equal "stats\n"
+    end
+  end
+
+  describe "#connect" do
+    it "should reconnect" do
+      c = $connect_count
+      @admin.connect
+      _(($connect_count - c)).must_equal 1
+    end
+  end
+end
+
+

data/spec/statsd_spec.rb

@@ -1,27 +1,43 @@
 require 'helper'
 
 describe Statsd do
-  class Statsd
-    public :socket
-  end
-
   before do
+    class Statsd
+      o, $VERBOSE = $VERBOSE, nil
+      alias connect_old connect
+      def connect
+        $connect_count ||= 1
+        $connect_count += 1
+      end
+      $VERBOSE = o
+    end
+
     @statsd = Statsd.new('localhost', 1234)
-    @socket = Thread.current[:statsd_socket] = FakeUDPSocket.new
+    @socket = @statsd.instance_variable_set(:@socket, FakeUDPSocket.new)
   end
 
-  after { Thread.current[:statsd_socket] = nil }
+  after do
+    class Statsd
+      o, $VERBOSE = $VERBOSE, nil
+      alias connect connect_old
+      $VERBOSE = o
+    end
+  end
 
   describe "#initialize" do
     it "should set the host and port" do
-      @statsd.host.must_equal 'localhost'
-      @statsd.port.must_equal 1234
+      _(@statsd.host).must_equal 'localhost'
+      _(@statsd.port).must_equal 1234
     end
 
     it "should default the host to 127.0.0.1 and port to 8125" do
       statsd = Statsd.new
-      statsd.host.must_equal '127.0.0.1'
-      statsd.port.must_equal 8125
+      _(statsd.host).must_equal '127.0.0.1'
+      _(statsd.port).must_equal 8125
+    end
+
+    it "should set delimiter to period by default" do
+      _(@statsd.delimiter).must_equal "."
     end
   end
 
@@ -29,37 +45,54 @@ describe Statsd do
     it "should set host and port" do
       @statsd.host = '1.2.3.4'
       @statsd.port = 5678
-      @statsd.host.must_equal '1.2.3.4'
-      @statsd.port.must_equal 5678
+      _(@statsd.host).must_equal '1.2.3.4'
+      _(@statsd.port).must_equal 5678
     end
 
     it "should not resolve hostnames to IPs" do
       @statsd.host = 'localhost'
-      @statsd.host.must_equal 'localhost'
+      _(@statsd.host).must_equal 'localhost'
     end
 
     it "should set nil host to default" do
       @statsd.host = nil
-      @statsd.host.must_equal '127.0.0.1'
+      _(@statsd.host).must_equal '127.0.0.1'
     end
 
     it "should set nil port to default" do
       @statsd.port = nil
-      @statsd.port.must_equal 8125
+      _(@statsd.port).must_equal 8125
+    end
+
+    it "should allow an IPv6 address" do
+      @statsd.host = '::1'
+      _(@statsd.host).must_equal '::1'
+    end
+  end
+
+  describe "#delimiter" do
+    it "should set delimiter" do
+      @statsd.delimiter = "-"
+      _(@statsd.delimiter).must_equal "-"
+    end
+
+    it "should set default to period if not given a value" do
+      @statsd.delimiter = nil
+      _(@statsd.delimiter).must_equal "."
     end
   end
 
   describe "#increment" do
     it "should format the message according to the statsd spec" do
       @statsd.increment('foobar')
-      @socket.recv.must_equal ['foobar:1|c']
+      _(@socket.recv).must_equal ['foobar:1|c']
     end
 
     describe "with a sample rate" do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should format the message according to the statsd spec" do
         @statsd.increment('foobar', 0.5)
-        @socket.recv.must_equal ['foobar:1|c|@0.5']
+        _(@socket.recv).must_equal ['foobar:1|c|@0.5']
       end
     end
   end
@@ -67,14 +100,14 @@ describe Statsd do
   describe "#decrement" do
     it "should format the message according to the statsd spec" do
       @statsd.decrement('foobar')
-      @socket.recv.must_equal ['foobar:-1|c']
+      _(@socket.recv).must_equal ['foobar:-1|c']
     end
 
     describe "with a sample rate" do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should format the message according to the statsd spec" do
         @statsd.decrement('foobar', 0.5)
-        @socket.recv.must_equal ['foobar:-1|c|@0.5']
+        _(@socket.recv).must_equal ['foobar:-1|c|@0.5']
       end
     end
   end
@@ -82,16 +115,16 @@ describe Statsd do
   describe "#gauge" do
     it "should send a message with a 'g' type, per the nearbuy fork" do
       @statsd.gauge('begrutten-suffusion', 536)
-      @socket.recv.must_equal ['begrutten-suffusion:536|g']
+      _(@socket.recv).must_equal ['begrutten-suffusion:536|g']
       @statsd.gauge('begrutten-suffusion', -107.3)
-      @socket.recv.must_equal ['begrutten-suffusion:-107.3|g']
+      _(@socket.recv).must_equal ['begrutten-suffusion:-107.3|g']
     end
 
     describe "with a sample rate" do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should format the message according to the statsd spec" do
         @statsd.gauge('begrutten-suffusion', 536, 0.1)
-        @socket.recv.must_equal ['begrutten-suffusion:536|g|@0.1']
+        _(@socket.recv).must_equal ['begrutten-suffusion:536|g|@0.1']
       end
     end
   end
@@ -99,14 +132,29 @@ describe Statsd do
   describe "#timing" do
     it "should format the message according to the statsd spec" do
       @statsd.timing('foobar', 500)
-      @socket.recv.must_equal ['foobar:500|ms']
+      _(@socket.recv).must_equal ['foobar:500|ms']
     end
 
     describe "with a sample rate" do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should format the message according to the statsd spec" do
         @statsd.timing('foobar', 500, 0.5)
-        @socket.recv.must_equal ['foobar:500|ms|@0.5']
+        _(@socket.recv).must_equal ['foobar:500|ms|@0.5']
+      end
+    end
+  end
+
+  describe "#set" do
+    it "should format the message according to the statsd spec" do
+      @statsd.set('foobar', 765)
+      _(@socket.recv).must_equal ['foobar:765|s']
+    end
+
+    describe "with a sample rate" do
+      before { class << @statsd; def rand; 0; end; end } # ensure delivery
+      it "should format the message according to the statsd spec" do
+        @statsd.set('foobar', 500, 0.5)
+        _(@socket.recv).must_equal ['foobar:500|s|@0.5']
       end
     end
   end
@@ -114,12 +162,24 @@ describe Statsd do
   describe "#time" do
     it "should format the message according to the statsd spec" do
       @statsd.time('foobar') { 'test' }
-      @socket.recv.must_equal ['foobar:0|ms']
+      _(@socket.recv).must_equal ['foobar:0|ms']
     end
 
     it "should return the result of the block" do
       result = @statsd.time('foobar') { 'test' }
-      result.must_equal 'test'
+      _(result).must_equal 'test'
+    end
+
+    describe "when given a block with an explicit return" do
+      it "should format the message according to the statsd spec" do
+        lambda { @statsd.time('foobar') { return 'test' } }.call
+        _(@socket.recv).must_equal ['foobar:0|ms']
+      end
+
+      it "should return the result of the block" do
+        result = lambda { @statsd.time('foobar') { return 'test' } }.call
+        _(result).must_equal 'test'
+      end
     end
 
     describe "with a sample rate" do
@@ -127,7 +187,7 @@ describe Statsd do
 
       it "should format the message according to the statsd spec" do
         @statsd.time('foobar', 0.5) { 'test' }
-        @socket.recv.must_equal ['foobar:0|ms|@0.5']
+        _(@socket.recv).must_equal ['foobar:0|ms|@0.5']
       end
     end
   end
@@ -137,7 +197,7 @@ describe Statsd do
       before { class << @statsd; def rand; raise end; end }
       it "should send" do
         @statsd.timing('foobar', 500, 1)
-        @socket.recv.must_equal ['foobar:500|ms']
+        _(@socket.recv).must_equal ['foobar:500|ms']
       end
     end
 
@@ -145,14 +205,14 @@ describe Statsd do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should send" do
         @statsd.timing('foobar', 500, 0.5)
-        @socket.recv.must_equal ['foobar:500|ms|@0.5']
+        _(@socket.recv).must_equal ['foobar:500|ms|@0.5']
       end
     end
 
     describe "when the sample rate is less than a random value [0,1]" do
       before { class << @statsd; def rand; 1; end; end } # ensure no delivery
       it "should not send" do
-        @statsd.timing('foobar', 500, 0.5).must_equal nil
+        assert_nil @statsd.timing('foobar', 500, 0.5)
       end
     end
 
@@ -160,7 +220,7 @@ describe Statsd do
       before { class << @statsd; def rand; 0; end; end } # ensure delivery
       it "should send" do
         @statsd.timing('foobar', 500, 0.5)
-        @socket.recv.must_equal ['foobar:500|ms|@0.5']
+        _(@socket.recv).must_equal ['foobar:500|ms|@0.5']
       end
     end
   end
@@ -170,22 +230,22 @@ describe Statsd do
 
     it "should add namespace to increment" do
       @statsd.increment('foobar')
-      @socket.recv.must_equal ['service.foobar:1|c']
+      _(@socket.recv).must_equal ['service.foobar:1|c']
     end
 
     it "should add namespace to decrement" do
       @statsd.decrement('foobar')
-      @socket.recv.must_equal ['service.foobar:-1|c']
+      _(@socket.recv).must_equal ['service.foobar:-1|c']
     end
 
     it "should add namespace to timing" do
       @statsd.timing('foobar', 500)
-      @socket.recv.must_equal ['service.foobar:500|ms']
+      _(@socket.recv).must_equal ['service.foobar:500|ms']
     end
 
     it "should add namespace to gauge" do
       @statsd.gauge('foobar', 500)
-      @socket.recv.must_equal ['service.foobar:500|g']
+      _(@socket.recv).must_equal ['service.foobar:500|g']
     end
   end
 
@@ -194,22 +254,22 @@ describe Statsd do
 
     it "should add postfix to increment" do
       @statsd.increment('foobar')
-      @socket.recv.must_equal ['foobar.ip-23-45-56-78:1|c']
+      _(@socket.recv).must_equal ['foobar.ip-23-45-56-78:1|c']
     end
 
     it "should add postfix to decrement" do
       @statsd.decrement('foobar')
-      @socket.recv.must_equal ['foobar.ip-23-45-56-78:-1|c']
+      _(@socket.recv).must_equal ['foobar.ip-23-45-56-78:-1|c']
     end
 
     it "should add namespace to timing" do
       @statsd.timing('foobar', 500)
-      @socket.recv.must_equal ['foobar.ip-23-45-56-78:500|ms']
+      _(@socket.recv).must_equal ['foobar.ip-23-45-56-78:500|ms']
     end
 
     it "should add namespace to gauge" do
       @statsd.gauge('foobar', 500)
-      @socket.recv.must_equal ['foobar.ip-23-45-56-78:500|g']
+      _(@socket.recv).must_equal ['foobar.ip-23-45-56-78:500|g']
     end
   end
 
@@ -219,7 +279,7 @@ describe Statsd do
         [nil, false, ''].each do |value|
           @statsd.postfix = 'a postfix'
           @statsd.postfix = value
-          @statsd.postfix.must_equal nil
+          assert_nil @statsd.postfix
         end
       end
     end
@@ -234,7 +294,7 @@ describe Statsd do
 
       @statsd.increment('foobar')
 
-      @log.string.must_match "Statsd: foobar:1|c"
+      _(@log.string).must_match "Statsd: foobar:1|c"
     end
 
     it "should not write to the log unless debug" do
@@ -242,7 +302,7 @@ describe Statsd do
 
       @statsd.increment('foobar')
 
-      @log.string.must_be_empty
+      _(@log.string).must_be_empty
     end
   end
 
@@ -255,12 +315,25 @@ describe Statsd do
       class Statsd::SomeClass; end
       @statsd.increment(Statsd::SomeClass, 1)
 
-      @socket.recv.must_equal ['Statsd.SomeClass:1|c']
+      _(@socket.recv).must_equal ['Statsd.SomeClass:1|c']
+    end
+
+    describe "custom delimiter" do
+      before do
+        @statsd.delimiter = "-"
+      end
+
+      it "should replace ruby constant delimiter with custom delimiter" do
+        class Statsd::SomeOtherClass; end
+        @statsd.increment(Statsd::SomeOtherClass, 1)
+
+        _(@socket.recv).must_equal ['Statsd-SomeOtherClass:1|c']
+      end
     end
 
     it "should replace statsd reserved chars in the stat name" do
       @statsd.increment('ray@hostname.blah|blah.blah:blah', 1)
-      @socket.recv.must_equal ['ray_hostname.blah_blah.blah_blah:1|c']
+      _(@socket.recv).must_equal ['ray_hostname.blah_blah.blah_blah:1|c']
     end
   end
 
@@ -268,29 +341,61 @@ describe Statsd do
     before do
       require 'stringio'
       Statsd.logger = Logger.new(@log = StringIO.new)
-      @socket.instance_eval { def send(*) raise SocketError end }
+      @socket.instance_variable_set(:@err_count, 0)
+      @socket.instance_eval { def write(*) @err_count+=1; raise SocketError end }
     end
 
     it "should ignore socket errors" do
-      @statsd.increment('foobar').must_equal nil
+      assert_nil @statsd.increment('foobar')
     end
 
     it "should log socket errors" do
       @statsd.increment('foobar')
-      @log.string.must_match 'Statsd: SocketError'
+      _(@log.string).must_match 'Statsd: SocketError'
+    end
+
+    it "should retry and reconnect on socket errors" do
+      $connect_count = 0
+      @statsd.increment('foobar')
+      _(@socket.instance_variable_get(:@err_count)).must_equal 5
+      _($connect_count).must_equal 5
     end
   end
 
   describe "batching" do
     it "should have a default batch size of 10" do
-      @statsd.batch_size.must_equal 10
+      _(@statsd.batch_size).must_equal 10
+    end
+
+    it "should have a default batch byte size of nil" do
+      assert_nil @statsd.batch_byte_size
+    end
+
+    it "should have a default flush interval of nil" do
+      assert_nil @statsd.flush_interval
     end
 
     it "should have a modifiable batch size" do
       @statsd.batch_size = 7
-      @statsd.batch_size.must_equal 7
+      _(@statsd.batch_size).must_equal 7
+      @statsd.batch do |b|
+        _(b.batch_size).must_equal 7
+      end
+
+      @statsd.batch_size = nil
+      @statsd.batch_byte_size = 1472
+      @statsd.batch do |b|
+        assert_nil b.batch_size
+        _(b.batch_byte_size).must_equal 1472
+      end
+
+    end
+
+    it 'should have a modifiable flush interval' do
+      @statsd.flush_interval = 1
+      _(@statsd.flush_interval).must_equal 1
       @statsd.batch do |b|
-        b.batch_size.must_equal 7
+        _(b.flush_interval).must_equal 1
       end
     end
 
@@ -302,50 +407,195 @@ describe Statsd do
         # block is done.
         5.times { b.increment('foobar') }
 
-        @socket.recv.must_equal [(["foobar:1|c"] * 3).join("\n")]
+        _(@socket.recv).must_equal [(["foobar:1|c"] * 3).join("\n")]
       end
 
-      @socket.recv.must_equal [(["foobar:1|c"] * 2).join("\n")]
+      _(@socket.recv).must_equal [(["foobar:1|c"] * 2).join("\n")]
+    end
+
+    it "should flush based on batch byte size" do
+      @statsd.batch do |b|
+        b.batch_size = nil
+        b.batch_byte_size = 22
+
+        # The first two should flush, the last will be flushed when the
+        # block is done.
+        3.times { b.increment('foobar') }
+
+        _(@socket.recv).must_equal [(["foobar:1|c"] * 2).join("\n")]
+      end
+
+      _(@socket.recv).must_equal ["foobar:1|c"]
+    end
+
+    it "should flush immediately when the queue is exactly a batch size" do
+      @statsd.batch do |b|
+        b.batch_size = nil
+        b.batch_byte_size = 21
+
+        # The first two should flush together
+        2.times { b.increment('foobar') }
+
+        _(@socket.recv).must_equal [(["foobar:1|c"] * 2).join("\n")]
+      end
+    end
+
+    it "should flush when the interval has passed" do
+      @statsd.batch do |b|
+        b.batch_size = nil
+        b.flush_interval = 0.01
+
+        # The first two should flush, the last will be flushed when the
+        # block is done.
+        2.times { b.increment('foobar') }
+        sleep(0.03)
+        b.increment('foobar')
+
+        _(@socket.recv).must_equal [(["foobar:1|c"] * 2).join("\n")]
+      end
+
+      _(@socket.recv).must_equal ["foobar:1|c"]
     end
 
     it "should not flush to the socket if the backlog is empty" do
       batch = Statsd::Batch.new(@statsd)
       batch.flush
-      @socket.recv.must_be :nil?
+      _(@socket.recv).must_be :nil?
 
       batch.increment 'foobar'
       batch.flush
-      @socket.recv.must_equal %w[foobar:1|c]
+      _(@socket.recv).must_equal %w[foobar:1|c]
     end
 
-  end
-
-  describe "thread safety" do
+    it "should support setting namespace for the underlying instance" do
+      batch = Statsd::Batch.new(@statsd)
+      batch.namespace = 'ns'
+      _(@statsd.namespace).must_equal 'ns'
+    end
 
-    it "should use a thread local socket" do
-      Thread.current[:statsd_socket].must_equal @socket
-      @statsd.send(:socket).must_equal @socket
+    it "should support setting host for the underlying instance" do
+      batch = Statsd::Batch.new(@statsd)
+      batch.host = '1.2.3.4'
+      _(@statsd.host).must_equal '1.2.3.4'
     end
 
-    it "should create a new socket when used in a new thread" do
-      sock = @statsd.send(:socket)
-      Thread.new { Thread.current[:statsd_socket].wont_equal sock }.join
+    it "should support setting port for the underlying instance" do
+      batch = Statsd::Batch.new(@statsd)
+      batch.port = 42
+      _(@statsd.port).must_equal 42
     end
 
   end
+
+  describe "#connect" do
+    it "should reconnect" do
+      c = $connect_count
+      @statsd.connect
+      _(($connect_count - c)).must_equal 1
+    end
+  end
+
 end
 
 describe Statsd do
   describe "with a real UDP socket" do
     it "should actually send stuff over the socket" do
-      socket = UDPSocket.new
-      host, port = 'localhost', 12345
-      socket.bind(host, port)
+      family = Addrinfo.udp(UDPSocket.getaddress('localhost'), 0).afamily
+      begin
+        socket = UDPSocket.new family
+        host, port = 'localhost', 0
+        socket.bind(host, port)
+        port = socket.addr[1]
+
+        statsd = Statsd.new(host, port)
+        statsd.increment('foobar')
+        message = socket.recvfrom(16).first
+        _(message).must_equal 'foobar:1|c'
+      ensure
+        socket.close
+      end
+    end
+
+    it "should send stuff over an IPv4 socket" do
+      begin
+        socket = UDPSocket.new Socket::AF_INET
+        host, port = '127.0.0.1', 0
+        socket.bind(host, port)
+        port = socket.addr[1]
+
+        statsd = Statsd.new(host, port)
+        statsd.increment('foobar')
+        message = socket.recvfrom(16).first
+        _(message).must_equal 'foobar:1|c'
+      ensure
+        socket.close
+      end
+    end
 
-      statsd = Statsd.new(host, port)
-      statsd.increment('foobar')
-      message = socket.recvfrom(16).first
-      message.must_equal 'foobar:1|c'
+    it "should send stuff over an IPv6 socket" do
+      begin
+        socket = UDPSocket.new Socket::AF_INET6
+        host, port = '::1', 0
+        socket.bind(host, port)
+        port = socket.addr[1]
+
+        statsd = Statsd.new(host, port)
+        statsd.increment('foobar')
+        message = socket.recvfrom(16).first
+        _(message).must_equal 'foobar:1|c'
+      ensure
+        socket.close
+      end
     end
   end
-end if ENV['LIVE']
+
+  describe "supports TCP sockets" do
+    it "should connect to and send stats over TCPv4" do
+      begin
+        host, port = '127.0.0.1', 0
+        server = TCPServer.new host, port
+        port = server.addr[1]
+
+        socket = nil
+        Thread.new { socket = server.accept }
+
+        statsd = Statsd.new(host, port, :tcp)
+        statsd.increment('foobar')
+
+        Timeout.timeout(5) do
+          Thread.pass while socket == nil
+        end
+
+        message = socket.recvfrom(16).first
+        _(message).must_equal "foobar:1|c\n"
+      ensure
+        socket.close if socket
+        server.close
+      end
+    end
+
+    it "should connect to and send stats over TCPv6" do
+      begin
+        host, port = '::1', 0
+        server = TCPServer.new host, port
+        port = server.addr[1]
+
+        socket = nil
+        Thread.new { socket = server.accept }
+
+        statsd = Statsd.new(host, port, :tcp)
+        statsd.increment('foobar')
+
+        Timeout.timeout(5) do
+          Thread.pass while socket == nil
+        end
+
+        message = socket.recvfrom(16).first
+        _(message).must_equal "foobar:1|c\n"
+      ensure
+        socket.close if socket
+        server.close
+      end
+    end
+  end
+end