statsd-instrument 3.0.0.pre2 → 3.1.1

data/test/statsd_test.rb

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class StatsDTest < Minitest::Test
   include StatsD::Instrument::Assertions
 
   def test_statsd_measure_with_explicit_value
-    metric = capture_statsd_call { StatsD.measure('values.foobar', 42) }
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
-    assert_equal :ms, metric.type
+    metric = capture_statsd_call { StatsD.measure("values.foobar", 42) }
+    assert_equal("values.foobar", metric.name)
+    assert_equal(42, metric.value)
+    assert_equal(:ms, metric.type)
   end
 
   def test_statsd_measure_with_explicit_value_and_sample_rate
-    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, sample_rate: 0.1) }
-    assert_equal 0.1, metric.sample_rate
+    metric = capture_statsd_call { StatsD.measure("values.foobar", 42, sample_rate: 0.1) }
+    assert_equal(0.1, metric.sample_rate)
   end
 
   def test_statsd_measure_with_benchmarked_block_duration
     Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
-      StatsD.measure('values.foobar') { 'foo' }
+      StatsD.measure("values.foobar") { "foo" }
     end
-    assert_equal 1120.0, metric.value
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_measure_returns_return_value_of_block
-    return_value = StatsD.measure('values.foobar') { 'sarah' }
-    assert_equal 'sarah', return_value
+    return_value = StatsD.measure("values.foobar") { "sarah" }
+    assert_equal("sarah", return_value)
   end
 
   def test_statsd_measure_with_return_in_block_still_captures
@@ -35,14 +35,14 @@ class StatsDTest < Minitest::Test
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
-        StatsD.measure('values.foobar') { return 'from lambda' }
+        StatsD.measure("values.foobar") { return "from lambda" }
       end
 
       result = lambda.call
     end
 
-    assert_equal 'from lambda', result
-    assert_equal 1120.0, metric.value
+    assert_equal("from lambda", result)
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_measure_with_exception_in_block_still_captures
@@ -50,73 +50,74 @@ class StatsDTest < Minitest::Test
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
-        StatsD.measure('values.foobar') { raise 'from lambda' }
+        StatsD.measure("values.foobar") { raise "from lambda" }
       end
 
       begin
         result = lambda.call
-      rescue # rubocop:disable Lint/HandleExceptions:
+      rescue
+        # noop
       end
     end
 
-    assert_nil result
-    assert_equal 1120.0, metric.value
+    assert_nil(result)
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_increment
-    metric = capture_statsd_call { StatsD.increment('values.foobar', 3) }
-    assert_equal :c, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 3, metric.value
+    metric = capture_statsd_call { StatsD.increment("values.foobar", 3) }
+    assert_equal(:c, metric.type)
+    assert_equal("values.foobar", metric.name)
+    assert_equal(3, metric.value)
   end
 
   def test_statsd_increment_with_hash_argument
-    metric = capture_statsd_call { StatsD.increment('values.foobar', tags: ['test']) }
-    assert_equal StatsD.singleton_client.default_sample_rate, metric.sample_rate
-    assert_equal ['test'], metric.tags
-    assert_equal 1, metric.value
+    metric = capture_statsd_call { StatsD.increment("values.foobar", tags: ["test"]) }
+    assert_equal(StatsD.singleton_client.default_sample_rate, metric.sample_rate)
+    assert_equal(["test"], metric.tags)
+    assert_equal(1, metric.value)
   end
 
   def test_statsd_gauge
-    metric = capture_statsd_call { StatsD.gauge('values.foobar', 12) }
-    assert_equal :g, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 12, metric.value
+    metric = capture_statsd_call { StatsD.gauge("values.foobar", 12) }
+    assert_equal(:g, metric.type)
+    assert_equal("values.foobar", metric.name)
+    assert_equal(12, metric.value)
   end
 
   def test_statsd_gauge_without_value
-    assert_raises(ArgumentError) { StatsD.gauge('values.foobar') }
+    assert_raises(ArgumentError) { StatsD.gauge("values.foobar") }
   end
 
   def test_statsd_set
-    metric = capture_statsd_call { StatsD.set('values.foobar', 'unique_identifier') }
-    assert_equal :s, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 'unique_identifier', metric.value
+    metric = capture_statsd_call { StatsD.set("values.foobar", "unique_identifier") }
+    assert_equal(:s, metric.type)
+    assert_equal("values.foobar", metric.name)
+    assert_equal("unique_identifier", metric.value)
   end
 
   def test_statsd_histogram
-    metric = capture_statsd_call { StatsD.histogram('values.foobar', 42) }
-    assert_equal :h, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
+    metric = capture_statsd_call { StatsD.histogram("values.foobar", 42) }
+    assert_equal(:h, metric.type)
+    assert_equal("values.foobar", metric.name)
+    assert_equal(42, metric.value)
   end
 
   def test_statsd_distribution
-    metric = capture_statsd_call { StatsD.distribution('values.foobar', 42) }
-    assert_equal :d, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
+    metric = capture_statsd_call { StatsD.distribution("values.foobar", 42) }
+    assert_equal(:d, metric.type)
+    assert_equal("values.foobar", metric.name)
+    assert_equal(42, metric.value)
   end
 
   def test_statsd_distribution_with_benchmarked_block_duration
     Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
-      result = StatsD.distribution('values.foobar') { 'foo' }
-      assert_equal 'foo', result
+      result = StatsD.distribution("values.foobar") { "foo" }
+      assert_equal("foo", result)
     end
-    assert_equal :d, metric.type
-    assert_equal 1120.0, metric.value
+    assert_equal(:d, metric.type)
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_distribution_with_return_in_block_still_captures
@@ -124,16 +125,16 @@ class StatsDTest < Minitest::Test
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
-        StatsD.distribution('values.foobar') { return 'from lambda' }
+        StatsD.distribution("values.foobar") { return "from lambda" }
         flunk("This code should not be reached")
       end
 
       result = lambda.call
     end
 
-    assert_equal 'from lambda', result
-    assert_equal :d, metric.type
-    assert_equal 1120.0, metric.value
+    assert_equal("from lambda", result)
+    assert_equal(:d, metric.type)
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_distribution_with_exception_in_block_still_captures
@@ -141,44 +142,45 @@ class StatsDTest < Minitest::Test
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
-        StatsD.distribution('values.foobar') { raise 'from lambda' }
+        StatsD.distribution("values.foobar") { raise "from lambda" }
       end
 
       begin
         result = lambda.call
-      rescue # rubocop:disable Lint/HandleExceptions
+      rescue
+        # noop
       end
     end
 
-    assert_nil result
-    assert_equal :d, metric.type
-    assert_equal 1120.0, metric.value
+    assert_nil(result)
+    assert_equal(:d, metric.type)
+    assert_equal(1120.0, metric.value)
   end
 
   def test_statsd_distribution_with_block_and_options
     Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
-      StatsD.distribution('values.foobar', tags: ['test'], sample_rate: 0.9) { 'foo' }
+      StatsD.distribution("values.foobar", tags: ["test"], sample_rate: 0.9) { "foo" }
     end
-    assert_equal 1120.0, metric.value
-    assert_equal 'values.foobar', metric.name
-    assert_equal 0.9, metric.sample_rate
-    assert_equal ['test'], metric.tags
+    assert_equal(1120.0, metric.value)
+    assert_equal("values.foobar", metric.name)
+    assert_equal(0.9, metric.sample_rate)
+    assert_equal(["test"], metric.tags)
   end
 
   def test_statsd_distribution_returns_return_value_of_block
-    return_value = StatsD.distribution('values.foobar') { 'sarah' }
-    assert_equal 'sarah', return_value
+    return_value = StatsD.distribution("values.foobar") { "sarah" }
+    assert_equal("sarah", return_value)
   end
 
   def test_statsd_measure_returns_return_value_of_block_even_if_nil
-    return_value = StatsD.distribution('values.foobar') { nil }
-    assert_nil return_value
+    return_value = StatsD.distribution("values.foobar") { nil }
+    assert_nil(return_value)
   end
 
   def test_statsd_duration_returns_time_in_seconds
     duration = StatsD::Instrument.duration {}
-    assert_kind_of Float, duration
+    assert_kind_of(Float, duration)
   end
 
   def test_statsd_duration_does_not_swallow_exceptions
@@ -191,7 +193,7 @@ class StatsDTest < Minitest::Test
 
   def capture_statsd_call(&block)
     metrics = capture_statsd_calls(&block)
-    assert_equal 1, metrics.length
+    assert_equal(1, metrics.length)
     metrics.first
   end
 end

data/test/test_helper.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
-ENV['ENV'] = 'test'
+if Warning.respond_to?(:[]=)
+  Warning[:deprecated] = true
+end
+
+ENV["ENV"] = "test"
 
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'mocha/setup'
-require 'statsd-instrument'
+require "minitest/autorun"
+require "minitest/pride"
+require "mocha/minitest"
+require "statsd-instrument"
 
-require_relative 'helpers/rubocop_helper'
+require_relative "helpers/rubocop_helper"
 
-module StatsD::Instrument
-  def self.strict_mode_enabled?
-    StatsD::Instrument.const_defined?(:Strict) &&
-      StatsD.singleton_class.ancestors.include?(StatsD::Instrument::Strict)
+module StatsD
+  module Instrument
+    def self.strict_mode_enabled?
+      StatsD::Instrument.const_defined?(:Strict) &&
+        StatsD.singleton_class.ancestors.include?(StatsD::Instrument::Strict)
+    end
   end
 end
 
 StatsD.logger = Logger.new(File::NULL)
+
+Thread.abort_on_exception = true
+Thread.report_on_exception = true

data/test/udp_sink_test.rb

@@ -1,83 +1,181 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-
-class UDPSinkTest < Minitest::Test
-  def setup
-    @receiver = UDPSocket.new
-    @receiver.bind('localhost', 0)
-    @host = @receiver.addr[2]
-    @port = @receiver.addr[1]
-  end
-
-  def teardown
-    @receiver.close
-  end
+require "test_helper"
 
+module UDPSinkTests
   def test_udp_sink_sends_data_over_udp
-    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
-    udp_sink << 'foo:1|c'
+    udp_sink = build_sink(@host, @port)
+    udp_sink << "foo:1|c"
 
     datagram, _source = @receiver.recvfrom(100)
-    assert_equal 'foo:1|c', datagram
+    assert_equal("foo:1|c", datagram)
+  end
+
+  def large_datagram
+    datagram = "#{"a" * 1000}:1|c"
+    udp_sink = build_sink(@host, @port)
+    udp_sink << datagram
+
+    datagram, _source = @receiver.recvfrom(1500)
+    assert_equal(datagram, datagram)
   end
 
   def test_sample?
-    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
-    assert udp_sink.sample?(1)
-    refute udp_sink.sample?(0)
+    udp_sink = build_sink(@host, @port)
+    assert(udp_sink.sample?(1))
+    refute(udp_sink.sample?(0))
 
     udp_sink.stubs(:rand).returns(0.3)
-    assert udp_sink.sample?(0.5)
+    assert(udp_sink.sample?(0.5))
 
     udp_sink.stubs(:rand).returns(0.7)
-    refute udp_sink.sample?(0.5)
+    refute(udp_sink.sample?(0.5))
   end
 
   def test_parallelism
-    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
-    50.times { |i| Thread.new { udp_sink << "foo:#{i}|c" << "bar:#{i}|c" } }
+    udp_sink = build_sink(@host, @port)
+    50.times.map { |i| Thread.new { udp_sink << "foo:#{i}|c" << "bar:#{i}|c" } }
     datagrams = []
-    100.times do
-      datagram, _source = @receiver.recvfrom(100)
-      datagrams << datagram
+
+    while @receiver.wait_readable(2)
+      datagram, _source = @receiver.recvfrom(4000)
+      datagrams += datagram.split("\n")
     end
 
-    assert_equal 100, datagrams.size
+    assert_equal(100, datagrams.size)
   end
 
-  def test_socket_error_should_invalidate_socket
-    UDPSocket.stubs(:new).returns(socket = mock('socket'))
-
-    seq = sequence('connect_fail_connect_succeed')
-    socket.expects(:connect).with('localhost', 8125).in_sequence(seq)
-    socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
-    socket.expects(:connect).with('localhost', 8125).in_sequence(seq)
-    socket.expects(:send).returns(1).in_sequence(seq)
-
-    udp_sink = StatsD::Instrument::UDPSink.new('localhost', 8125)
-    udp_sink << 'foo:1|c'
-    udp_sink << 'bar:1|c'
+  class SimpleFormatter < ::Logger::Formatter
+    def call(_severity, _timestamp, _progname, msg)
+      "#{String === msg ? msg : msg.inspect}\n"
+    end
   end
 
   def test_sends_datagram_in_signal_handler
-    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    udp_sink = build_sink(@host, @port)
+    Signal.trap("USR1") { udp_sink << "exiting:1|c" }
+
     pid = fork do
-      Signal.trap('TERM') do
-        udp_sink << "exiting:1|c"
-        Process.exit!(0)
-      end
+      sleep(5)
+    end
+
+    Signal.trap("USR1", "DEFAULT")
+
+    Process.kill("USR1", pid)
+    @receiver.wait_readable(1)
+    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
+    Process.kill("KILL", pid)
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
+  end
 
-      sleep(10)
+  def test_sends_datagram_before_exit
+    udp_sink = build_sink(@host, @port)
+    fork do
+      udp_sink << "exiting:1|c"
+      Process.exit(0)
     end
 
-    Process.kill('TERM', pid)
-    _, exit_status = Process.waitpid2(pid)
+    @receiver.wait_readable(1)
+    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
+  end
 
-    assert_equal 0, exit_status, "The forked process did not exit cleanly"
-    assert_equal "exiting:1|c", @receiver.recvfrom_nonblock(100).first
+  def test_sends_datagram_when_termed
+    udp_sink = build_sink(@host, @port)
+    fork do
+      udp_sink << "exiting:1|c"
+      Process.kill("TERM", Process.pid)
+    end
 
+    @receiver.wait_readable(1)
+    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
   rescue NotImplementedError
     pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
+
+  private
+
+  def build_sink(host = @host, port = @port)
+    @sink_class.new(host, port)
+  end
+
+  class UDPSinkTest < Minitest::Test
+    include UDPSinkTests
+
+    def setup
+      @receiver = UDPSocket.new
+      @receiver.bind("localhost", 0)
+      @host = @receiver.addr[2]
+      @port = @receiver.addr[1]
+      @sink_class = StatsD::Instrument::UDPSink
+    end
+
+    def teardown
+      @receiver.close
+    end
+
+    def test_socket_error_should_invalidate_socket
+      previous_logger = StatsD.logger
+      begin
+        logs = StringIO.new
+        StatsD.logger = Logger.new(logs)
+        StatsD.logger.formatter = SimpleFormatter.new
+        UDPSocket.stubs(:new).returns(socket = mock("socket"))
+
+        seq = sequence("connect_fail_connect_succeed")
+        socket.expects(:connect).with("localhost", 8125).in_sequence(seq)
+        socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
+        socket.expects(:connect).with("localhost", 8125).in_sequence(seq)
+        socket.expects(:send).returns(1).in_sequence(seq)
+
+        udp_sink = build_sink("localhost", 8125)
+        udp_sink << "foo:1|c"
+        udp_sink << "bar:1|c"
+
+        assert_equal(
+          "[#{@sink_class}] Resetting connection because of " \
+          "Errno::EDESTADDRREQ: Destination address required\n",
+          logs.string,
+        )
+      ensure
+        StatsD.logger = previous_logger
+      end
+    end
+  end
+
+  class BatchedUDPSinkTest < Minitest::Test
+    include UDPSinkTests
+
+    def setup
+      @receiver = UDPSocket.new
+      @receiver.bind("localhost", 0)
+      @host = @receiver.addr[2]
+      @port = @receiver.addr[1]
+      @sink_class = StatsD::Instrument::BatchedUDPSink
+    end
+
+    def teardown
+      @receiver.close
+    end
+
+    def test_parallelism_buffering
+      udp_sink = build_sink(@host, @port)
+      50.times.map do |i|
+        Thread.new do
+          udp_sink << "foo:#{i}|c" << "bar:#{i}|c" << "baz:#{i}|c" << "plop:#{i}|c"
+        end
+      end
+
+      datagrams = []
+
+      while @receiver.wait_readable(2)
+        datagram, _source = @receiver.recvfrom(1000)
+        datagrams += datagram.split("\n")
+      end
+
+      assert_equal(200, datagrams.size)
+    end
+  end
 end