statsd-instrument 3.0.2 → 3.1.0

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)
+    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) }
+    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)
   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,13 +35,13 @@ 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("from lambda", result)
     assert_equal(1120.0, metric.value)
   end
 
@@ -50,7 +50,7 @@ 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
@@ -65,56 +65,56 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_increment
-    metric = capture_statsd_call { StatsD.increment('values.foobar', 3) }
+    metric = capture_statsd_call { StatsD.increment("values.foobar", 3) }
     assert_equal(:c, metric.type)
-    assert_equal('values.foobar', metric.name)
+    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']) }
+    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(["test"], metric.tags)
     assert_equal(1, metric.value)
   end
 
   def test_statsd_gauge
-    metric = capture_statsd_call { StatsD.gauge('values.foobar', 12) }
+    metric = capture_statsd_call { StatsD.gauge("values.foobar", 12) }
     assert_equal(:g, metric.type)
-    assert_equal('values.foobar', metric.name)
+    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') }
+    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)
+    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) }
+    metric = capture_statsd_call { StatsD.histogram("values.foobar", 42) }
     assert_equal(:h, metric.type)
-    assert_equal('values.foobar', metric.name)
+    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) }
+    metric = capture_statsd_call { StatsD.distribution("values.foobar", 42) }
     assert_equal(:d, metric.type)
-    assert_equal('values.foobar', metric.name)
+    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)
@@ -125,14 +125,14 @@ 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("from lambda", result)
     assert_equal(:d, metric.type)
     assert_equal(1120.0, metric.value)
   end
@@ -142,7 +142,7 @@ 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
@@ -160,21 +160,21 @@ class StatsDTest < Minitest::Test
   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("values.foobar", metric.name)
     assert_equal(0.9, metric.sample_rate)
-    assert_equal(['test'], metric.tags)
+    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 }
+    return_value = StatsD.distribution("values.foobar") { nil }
     assert_nil(return_value)
   end
 

data/test/test_helper.rb

@@ -1,13 +1,17 @@
 # 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/minitest'
-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
   module Instrument
@@ -19,3 +23,6 @@ module StatsD
 end
 
 StatsD.logger = Logger.new(File::NULL)
+
+Thread.abort_on_exception = true
+Thread.report_on_exception = true

data/test/udp_sink_test.rb

@@ -1,29 +1,27 @@
 # 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)
+    udp_sink = build_sink(@host, @port)
     assert(udp_sink.sample?(1))
     refute(udp_sink.sample?(0))
 
@@ -35,49 +33,123 @@ class UDPSinkTest < Minitest::Test
   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)
   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)
-    pid = fork do
-      Signal.trap('TERM') do
-        udp_sink << "exiting:1|c"
-        Process.exit!(0)
-      end
+    udp_sink = build_sink(@host, @port)
+    Signal.trap("USR1") { udp_sink << "exiting:1|c" }
 
-      sleep(10)
+    pid = fork do
+      sleep(5)
     end
 
-    Process.kill('TERM', pid)
-    _, exit_status = Process.waitpid2(pid)
+    Signal.trap("USR1", "DEFAULT")
 
-    assert_equal(0, exit_status, "The forked process did not exit cleanly")
+    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
+
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,8 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
-dependencies: []
+date: 2021-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  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: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
   StatsD instrumentation into your code.
 email:
@@ -23,7 +37,8 @@ files:
 - ".github/CODEOWNERS"
 - ".github/probots.yml"
 - ".github/workflows/benchmark.yml"
-- ".github/workflows/ci.yml"
+- ".github/workflows/lint.yml"
+- ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".yardopts"
@@ -41,6 +56,7 @@ files:
 - lib/statsd-instrument.rb
 - lib/statsd/instrument.rb
 - lib/statsd/instrument/assertions.rb
+- lib/statsd/instrument/batched_udp_sink.rb
 - lib/statsd/instrument/capture_sink.rb
 - lib/statsd/instrument/client.rb
 - lib/statsd/instrument/datagram.rb