statsd-instrument 2.3.2 → 2.6.0

data/test/statsd_test.rb

@@ -1,166 +1,177 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class StatsDTest < Minitest::Test
   include StatsD::Instrument::Assertions
 
+  def teardown
+    StatsD.default_tags = nil
+  end
+
   def test_statsd_passed_collections_to_backend
     StatsD.backend.expects(:collect_metric).with(instance_of(StatsD::Instrument::Metric))
     StatsD.increment('test')
   end
 
   def test_statsd_measure_with_explicit_value
-    result = nil
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', 42) }
-    assert_equal metric, result
+    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_distribution_override
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', 42, as_dist: true) }
-    assert_equal :d, metric.type
-  end
-
-  def test_statsd_measure_with_explicit_value_as_keyword_argument
-    result = nil
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', value: 42) }
-    assert_equal metric, result
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
-    assert_equal :ms, metric.type
-  end
-
-  def test_statsd_measure_with_explicit_value_keyword_and_distribution_override
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', value: 42, as_dist: true) }
-    assert_equal :d, metric.type
-  end
-
   def test_statsd_measure_without_value_or_block
     assert_raises(ArgumentError) { StatsD.measure('values.foobar', tags: 123) }
   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
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
       StatsD.measure('values.foobar') { 'foo' }
     end
     assert_equal 1120.0, metric.value
   end
 
-  def test_statsd_measure_use_distribution_override_for_a_block
-    metric = capture_statsd_call do
-      StatsD.measure('values.foobar', as_dist: true) { 'foo' }
-    end
-    assert_equal :d, metric.type
-  end
-
   def test_statsd_measure_returns_return_value_of_block
     return_value = StatsD.measure('values.foobar') { 'sarah' }
     assert_equal 'sarah', return_value
   end
 
-  def test_statsd_measure_returns_return_value_of_block_even_if_nil
-    return_value = StatsD.measure('values.foobar', as_dist: true) { nil }
-    assert_nil return_value
+  def test_statsd_measure_with_return_in_block_still_captures
+    Process.stubs(:clock_gettime).returns(5.0, 6.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.measure('values.foobar') { return 'from lambda' }
+      end
+
+      result = lambda.call
+    end
+
+    assert_equal 'from lambda', result
+    assert_equal 1120.0, metric.value
   end
 
-  def test_statsd_increment
+  def test_statsd_measure_with_exception_in_block_still_captures
+    Process.stubs(:clock_gettime).returns(5.0, 6.12)
     result = nil
-    metric = capture_statsd_call { result = StatsD.increment('values.foobar', 3) }
-    assert_equal metric, result
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.measure('values.foobar') { raise 'from lambda' }
+      end
+
+      begin
+        result = lambda.call
+      rescue # rubocop:disable Lint/HandleExceptions:
+      end
+    end
+
+    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
   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.default_sample_rate, metric.sample_rate
     assert_equal ['test'], metric.tags
     assert_equal 1, metric.value
   end
 
-  def test_statsd_increment_with_value_as_keyword_argument
-    metric = capture_statsd_call { StatsD.increment('values.foobar', :value => 2) }
-    assert_equal StatsD.default_sample_rate, metric.sample_rate
-    assert_equal 2, metric.value
-  end
-
-  def test_statsd_increment_with_multiple_arguments
-    metric = capture_statsd_call { StatsD.increment('values.foobar', 12, nil, ['test']) }
-    assert_equal StatsD.default_sample_rate, metric.sample_rate
-    assert_equal ['test'], metric.tags
-    assert_equal 12, metric.value
-  end
-
   def test_statsd_gauge
-    result = nil
-    metric = capture_statsd_call { result = StatsD.gauge('values.foobar', 12) }
-    assert_equal metric, result
+    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_with_keyword_argument
-    result = nil
-    metric = capture_statsd_call { result = StatsD.gauge('values.foobar', value: 13) }
-    assert_equal metric, result
-    assert_equal :g, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 13, metric.value
-  end
-
   def test_statsd_gauge_without_value
     assert_raises(ArgumentError) { StatsD.gauge('values.foobar', tags: 123) }
   end
 
   def test_statsd_set
-    result = nil
-    metric = capture_statsd_call { result = StatsD.set('values.foobar', 'unique_identifier') }
-    assert_equal metric, result
+    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
-    result = nil
-    metric = capture_statsd_call { result = StatsD.histogram('values.foobar', 42) }
-    assert_equal metric, result
+    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
-    result = nil
-    metric = capture_statsd_call { result = StatsD.distribution('values.foobar', 42) }
-    assert_equal metric, result
+    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
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
-      StatsD.distribution('values.foobar') { 'foo' }
+      result = StatsD.distribution('values.foobar') { 'foo' }
+      assert_equal 'foo', result
     end
     assert_equal :d, metric.type
     assert_equal 1120.0, metric.value
   end
 
+  def test_statsd_distribution_with_return_in_block_still_captures
+    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        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
+  end
+
+  def test_statsd_distribution_with_exception_in_block_still_captures
+    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.distribution('values.foobar') { raise 'from lambda' }
+      end
+
+      begin
+        result = lambda.call
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
+    end
+
+    assert_nil result
+    assert_equal :d, metric.type
+    assert_equal 1120.0, metric.value
+  end
+
   def test_statsd_distribution_with_block_and_options
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    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
@@ -179,14 +190,37 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_key_value
-    result = nil
-    metric = capture_statsd_call { result = StatsD.key_value('values.foobar', 42) }
-    assert_equal metric, result
+    metric = capture_statsd_call { StatsD.key_value('values.foobar', 42) }
     assert_equal :kv, metric.type
     assert_equal 'values.foobar', metric.name
     assert_equal 42, metric.value
   end
 
+  def test_statsd_durarion_returns_time_in_seconds
+    duration = StatsD::Instrument.duration {}
+    assert_kind_of Float, duration
+  end
+
+  def test_statsd_durarion_does_not_swallow_exceptions
+    assert_raises(RuntimeError) do
+      StatsD::Instrument.duration { raise "Foo" }
+    end
+  end
+
+  def test_statsd_default_tags_get_normalized
+    StatsD.default_tags = { first_tag: 'first_value', second_tag: 'second_value' }
+    assert_equal ['first_tag:first_value', 'second_tag:second_value'], StatsD.default_tags
+  end
+
+  def test_name_prefix
+    StatsD.stubs(:prefix).returns('prefix')
+    m = capture_statsd_call { StatsD.increment('counter') }
+    assert_equal 'prefix.counter', m.name
+
+    m = capture_statsd_call { StatsD.increment('counter', no_prefix: true) }
+    assert_equal 'counter', m.name
+  end
+
   protected
 
   def capture_statsd_call(&block)

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ENV['ENV'] = 'test'
 
 require 'minitest/autorun'
@@ -7,4 +9,13 @@ require 'set'
 require 'logger'
 require 'statsd-instrument'
 
-StatsD.logger = Logger.new('/dev/null')
+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)
+  end
+end
+
+StatsD.logger = Logger.new(File::NULL)

data/test/udp_backend_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class UDPBackendTest < Minitest::Test
@@ -76,7 +78,7 @@ class UDPBackendTest < Minitest::Test
     StatsD.histogram('fooh', 42.4)
   end
 
-   def test_distribution_syntax_on_datadog
+  def test_distribution_syntax_on_datadog
     @backend.implementation = :datadog
     @backend.expects(:write_packet).with('fooh:42.4|d')
     StatsD.distribution('fooh', 42.4)
@@ -84,20 +86,25 @@ class UDPBackendTest < Minitest::Test
 
   def test_event_on_datadog
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz|h:localhost:3000|@0.01|#foo')
-    StatsD.event('fooh', 'baz', hostname: 'localhost:3000', sample_rate: 0.01, tags: ["foo"])
+    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz|h:localhost|#foo')
+    StatsD.event('fooh', 'baz', hostname: 'localhost', tags: ["foo"])
   end
 
   def test_event_on_datadog_escapes_newlines
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{8,5}:fooh\\n\\n|baz\\n')
-    StatsD.event('fooh\n\n', 'baz\n')
+    @backend.expects(:write_packet).with("_e{8,5}:fooh\\n\\n|baz\\n")
+    StatsD.event("fooh\n\n", "baz\n")
   end
 
   def test_event_on_datadog_ignores_invalid_metadata
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz')
-    StatsD.event('fooh', 'baz', i_am_not_supported: 'not-supported')
+    if StatsD::Instrument.strict_mode_enabled?
+      assert_raises(ArgumentError) { StatsD.event('fooh', 'baz', sample_rate: 0.01) }
+      assert_raises(ArgumentError) { StatsD.event('fooh', 'baz', unsupported: 'foo') }
+    else
+      @backend.expects(:write_packet).with('_e{4,3}:fooh|baz')
+      StatsD.event('fooh', 'baz', sample_rate: 0.01, i_am_not_supported: 'not-supported')
+    end
   end
 
   def test_event_warns_when_not_using_datadog
@@ -109,14 +116,26 @@ class UDPBackendTest < Minitest::Test
 
   def test_service_check_on_datadog
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_sc|fooh|baz|h:localhost:3000|@0.01|#foo')
-    StatsD.service_check('fooh', 'baz', hostname: 'localhost:3000', sample_rate: 0.01, tags: ["foo"])
+    @backend.expects(:write_packet).with('_sc|fooh|0|h:localhost|#foo')
+    StatsD.service_check('fooh', 0, hostname: 'localhost', tags: ["foo"])
   end
 
   def test_service_check_on_datadog_ignores_invalid_metadata
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_sc|fooh|baz')
-    StatsD.service_check('fooh', 'baz', i_am_not_supported: 'not-supported')
+    if StatsD::Instrument.strict_mode_enabled?
+      assert_raises(ArgumentError) { StatsD.service_check('fooh', "warning", sample_rate: 0.01) }
+      assert_raises(ArgumentError) { StatsD.service_check('fooh', "warning", unsupported: 'foo') }
+    else
+      @backend.expects(:write_packet).with('_sc|fooh|1')
+      StatsD.service_check('fooh', "warning", sample_rate: 0.01, i_am_not_supported: 'not-supported')
+    end
+  end
+
+  def test_service_check_on_datadog_will_append_message_as_final_metadata_field
+    @backend.implementation = :datadog
+    @backend.expects(:write_packet).with('_sc|fooh|0|d:1230768000|#quc|m:Everything OK')
+    StatsD.service_check('fooh', :ok, message: "Everything OK",
+      timestamp: Time.parse('2009-01-01T00:00:00Z'), tags: ['quc'])
   end
 
   def test_service_check_warns_when_not_using_datadog
@@ -146,11 +165,19 @@ class UDPBackendTest < Minitest::Test
     StatsD.key_value('fooy', 42)
   end
 
+  # For key_value metrics (only supported by statsite), the sample rate
+  # part of the datagram format is (ab)used to be set to a timestamp instead.
+  # Changing that to `sample_rate: timestamp` does not make sense, so we
+  # disable the rubocop rule for positional arguments for now,
+  # until we figure out how we want to handle this.
+
+  # rubocop:disable StatsD/PositionalArguments
   def test_supports_key_value_with_timestamp_on_statsite
     @backend.implementation = :statsite
     @backend.expects(:write_packet).with("fooy:42|kv|@123456\n")
     StatsD.key_value('fooy', 42, 123456)
   end
+  # rubocop:enable StatsD/PositionalArguments
 
   def test_warn_when_using_key_value_and_not_on_statsite
     @backend.implementation = :other
@@ -183,31 +210,6 @@ class UDPBackendTest < Minitest::Test
     StatsD.increment('fail')
   end
 
-  def test_synchronize_in_exit_handler_handles_thread_error_and_exits_cleanly
-    pid = fork do
-      Signal.trap('TERM') do
-        $sent_packet = false
-
-        class << @backend.socket
-          def send(command, *args)
-            $sent_packet = true if command == 'exiting:1|c'
-            command.length
-          end
-        end
-
-        StatsD.increment('exiting')
-        Process.exit!($sent_packet)
-      end
-
-      sleep 100
-    end
-
-    Process.kill('TERM', pid)
-    Process.waitpid(pid)
-
-    assert $?.success?, 'socket did not write on exit'
-  end
-
   def test_socket_error_should_invalidate_socket
     seq = sequence('fail_then_succeed')
 

data/test/udp_sink_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+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
+
+  def test_udp_sink_sends_data_over_udp
+    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    udp_sink << 'foo:1|c'
+
+    datagram, _source = @receiver.recvfrom(100)
+    assert_equal 'foo:1|c', 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.stubs(:rand).returns(0.3)
+    assert udp_sink.sample?(0.5)
+
+    udp_sink.stubs(:rand).returns(0.7)
+    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" } }
+    datagrams = []
+    100.times do
+      datagram, _source = @receiver.recvfrom(100)
+      datagrams << datagram
+    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'
+  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
+
+      sleep(10)
+    end
+
+    Process.kill('TERM', pid)
+    _, exit_status = Process.waitpid2(pid)
+
+    assert_equal 0, exit_status, "The forked process did not exit cleanly"
+    assert_equal "exiting:1|c", @receiver.recvfrom_nonblock(100).first
+
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
+  end
+end