statsd-instrument 2.3.2 → 2.6.0

data/test/benchmark/tags.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'statsd-instrument'
 require 'benchmark/ips'
 
 Benchmark.ips do |bench|
   bench.report("normalized tags with simple hash") do
-    StatsD::Instrument::Metric.normalize_tags(:tag => 'value')
+    StatsD::Instrument::Metric.normalize_tags(tag: 'value')
   end
 
   bench.report("normalized tags with simple array") do
@@ -11,14 +13,14 @@ Benchmark.ips do |bench|
   end
 
   bench.report("normalized tags with large hash") do
-    StatsD::Instrument::Metric.normalize_tags({
+    StatsD::Instrument::Metric.normalize_tags(
       mobile: true,
       pod: "1",
       protocol: "https",
       country: "Langbortistan",
       complete: true,
       shop: "omg shop that has a longer name",
-    })
+    )
   end
 
   bench.report("normalized tags with large array") do

data/test/capture_backend_test.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class CaptureBackendTest < Minitest::Test
   def setup
     @backend = StatsD::Instrument::Backends::CaptureBackend.new
-    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter')
-    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123)
+    @metric1 = StatsD::Instrument::Metric.new(type: :c, name: 'mock.counter')
+    @metric2 = StatsD::Instrument::Metric.new(type: :ms, name: 'mock.measure', value: 123)
   end
 
   def test_collecting_metric

data/test/capture_sink_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class CaptureSinktest < Minitest::Test
+  def test_capture_sink_captures_datagram_instances
+    capture_sink = StatsD::Instrument::CaptureSink.new(parent: [])
+    capture_sink << 'foo:1|c'
+
+    assert_equal 1, capture_sink.datagrams.length
+    assert_kind_of StatsD::Instrument::Datagram, capture_sink.datagrams.first
+    assert_equal 'foo:1|c', capture_sink.datagrams.first.source
+  end
+
+  def test_capture_sink_sends_datagrams_to_parent
+    parent = []
+    capture_sink = StatsD::Instrument::CaptureSink.new(parent: parent)
+    capture_sink << 'foo:1|c' << 'bar:1|c'
+
+    assert_equal ['foo:1|c', 'bar:1|c'], parent
+  end
+
+  def test_nesting_capture_sink_instances
+    null_sink = StatsD::Instrument::NullSink.new
+    outer_capture_sink = StatsD::Instrument::CaptureSink.new(parent: null_sink)
+    inner_capture_sink = StatsD::Instrument::CaptureSink.new(parent: outer_capture_sink)
+
+    outer_capture_sink << 'foo:1|c'
+    inner_capture_sink << 'bar:1|c'
+
+    assert_equal ['foo:1|c', 'bar:1|c'], outer_capture_sink.datagrams.map(&:source)
+    assert_equal ['bar:1|c'], inner_capture_sink.datagrams.map(&:source)
+  end
+
+  def test_using_a_different_datagram_class
+    sink = StatsD::Instrument::CaptureSink.new(parent: [], datagram_class: String)
+    sink << 'foo:1|c'
+
+    assert sink.datagrams.all? { |datagram| datagram.is_a?(String) }
+    assert_equal ['foo:1|c'], sink.datagrams
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = StatsD::Instrument::Client.new(datagram_builder_class: StatsD::Instrument::StatsDDatagramBuilder)
+    @dogstatsd_client = StatsD::Instrument::Client.new(
+      datagram_builder_class: StatsD::Instrument::DogStatsDDatagramBuilder,
+    )
+  end
+
+  def test_capture
+    inner_datagrams = nil
+
+    @client.increment('foo')
+    outer_datagrams = @client.capture do
+      @client.increment('bar')
+      inner_datagrams = @client.capture do
+        @client.increment('baz')
+      end
+    end
+    @client.increment('quc')
+
+    assert_equal ['bar', 'baz'], outer_datagrams.map(&:name)
+    assert_equal ['baz'], inner_datagrams.map(&:name)
+  end
+
+  def test_metric_methods_return_nil
+    assert_nil @client.increment('foo')
+    assert_nil @client.measure('bar', 122.54)
+    assert_nil @client.set('baz', 123)
+    assert_nil @client.gauge('baz', 12.3)
+  end
+
+  def test_increment_with_default_value
+    datagrams = @client.capture { @client.increment('foo') }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:1|c', datagrams.first.source
+  end
+
+  def test_measure_with_value
+    datagrams = @client.capture { @client.measure('foo', 122.54) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:122.54|ms', datagrams.first.source
+  end
+
+  def test_measure_with_block
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @client.capture do
+      @client.measure('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:100.0|ms', datagrams.first.source
+  end
+
+  def test_gauge
+    datagrams = @client.capture { @client.gauge('foo', 123) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:123|g', datagrams.first.source
+  end
+
+  def test_set
+    datagrams = @client.capture { @client.set('foo', 12345) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12345|s', datagrams.first.source
+  end
+
+  def test_histogram
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.histogram('foo', 12.44) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12.44|h', datagrams.first.source
+  end
+
+  def test_distribution_with_value
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.distribution('foo', 12.44) }
+    assert_equal 1, datagrams.size
+    assert_equal 'foo:12.44|d', datagrams.first.source
+  end
+
+  def test_distribution_with_block
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @dogstatsd_client.capture do
+      @dogstatsd_client.distribution('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|d", datagrams.first.source
+  end
+
+  def test_latency_emits_ms_metric
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @client.capture do
+      @client.latency('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|ms", datagrams.first.source
+  end
+
+  def test_latency_on_dogstatsd_prefers_distribution_metric_type
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    datagrams = @dogstatsd_client.capture do
+      @dogstatsd_client.latency('foo') {}
+    end
+    assert_equal 1, datagrams.size
+    assert_equal "foo:100.0|d", datagrams.first.source
+  end
+
+  def test_latency_calls_block_even_when_not_sending_a_sample
+    called = false
+    @client.capture do
+      @client.latency('foo', sample_rate: 0) { called = true }
+    end
+    assert called, "The block should have been called"
+  end
+
+  def test_service_check
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.service_check('service', :ok) }
+    assert_equal 1, datagrams.size
+    assert_equal "_sc|service|0", datagrams.first.source
+  end
+
+  def test_event
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.event('service', "event\ndescription") }
+    assert_equal 1, datagrams.size
+    assert_equal "_e{7,18}:service|event\\ndescription", datagrams.first.source
+  end
+
+  def test_no_prefix
+    client = StatsD::Instrument::Client.new(prefix: 'foo')
+    datagrams = client.capture do
+      client.increment('bar')
+      client.increment('bar', no_prefix: true)
+    end
+
+    assert_equal 2, datagrams.size
+    assert_equal "foo.bar", datagrams[0].name
+    assert_equal "bar", datagrams[1].name
+  end
+
+  def test_sampling
+    mock_sink = mock('sink')
+    mock_sink.stubs(:sample?).returns(false, true, false, false, true)
+    mock_sink.expects(:<<).twice
+
+    client = StatsD::Instrument::Client.new(sink: mock_sink)
+    5.times { client.increment('metric') }
+  end
+
+  def test_clone_with_prefix_option
+    # Both clients will use the same sink.
+    mock_sink = mock('sink')
+    mock_sink.stubs(:sample?).returns(true)
+    mock_sink.expects(:<<).with("metric:1|c").returns(mock_sink)
+    mock_sink.expects(:<<).with("foo.metric:1|c").returns(mock_sink)
+
+    original_client = StatsD::Instrument::Client.new(sink: mock_sink)
+    client_with_other_options = original_client.clone_with_options(prefix: 'foo')
+
+    original_client.increment('metric')
+    client_with_other_options.increment('metric')
+  end
+end

data/test/compatibility/dogstatsd_datagram_compatibility_test.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/client'
+
+module Compatibility
+  class DogStatsDDatagramCompatibilityTest < Minitest::Test
+    def setup
+      StatsD::Instrument::UDPSink.any_instance.stubs(:sample?).returns(true)
+      StatsD::Instrument::Backends::UDPBackend.any_instance.stubs(:rand).returns(0)
+
+      @server = UDPSocket.new
+      @server.bind('localhost', 0)
+      @host = @server.addr[2]
+      @port = @server.addr[1]
+    end
+
+    def teardown
+      @server.close
+    end
+
+    def test_increment_compatibility
+      assert_equal_datagrams { |client| client.increment('counter') }
+      assert_equal_datagrams { |client| client.increment('counter', no_prefix: true) }
+      assert_equal_datagrams { |client| client.increment('counter', 12) }
+      assert_equal_datagrams { |client| client.increment('counter', sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.increment('counter', tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.increment('counter', tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.increment('counter', sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_measure_compatibility
+      assert_equal_datagrams { |client| client.measure('timing', 12.34) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.01, no_prefix: true) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.12, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.measure('timing', 0.12, tags: ['foo', 'bar']) }
+    end
+
+    def test_measure_with_block_compatibility
+      Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(12.1)
+      assert_equal_datagrams do |client|
+        return_value = client.measure('timing', tags: ['foo'], sample_rate: 0.1) { 'foo' }
+        assert_equal 'foo', return_value
+      end
+    end
+
+    def test_gauge_compatibility
+      assert_equal_datagrams { |client| client.gauge('current', 1234) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, no_prefix: true) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.gauge('current', 1234, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_set_compatibility
+      assert_equal_datagrams { |client| client.set('unique', 'foo') }
+      assert_equal_datagrams { |client| client.set('unique', 'foo', no_prefix: true) }
+      assert_equal_datagrams { |client| client.set('unique', 'foo', sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.set('unique', '1234', sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_histogram_compatibility
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, no_prefix: true) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.histogram('sample', 12.44, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_distribution_compatibility
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, no_prefix: true) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, sample_rate: 0.1) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, tags: ['foo', 'bar']) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, tags: { foo: 'bar' }) }
+      assert_equal_datagrams { |client| client.distribution('sample', 12.44, sample_rate: 0.1, tags: ['quc']) }
+    end
+
+    def test_distribution_with_block_compatibility
+      Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(12.1)
+      assert_equal_datagrams do |client|
+        return_value = client.distribution('timing', tags: ['foo'], sample_rate: 0.1) { 'foo' }
+        assert_equal 'foo', return_value
+      end
+    end
+
+    def test_service_check_compatibility
+      assert_equal_datagrams { |client| client.service_check('service', 0) }
+      assert_equal_datagrams { |client| client.service_check('service', :critical, no_prefix: true) }
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz") }
+      assert_equal_datagrams do |client|
+        client.service_check('service', "ok", timestamp: Time.parse('2019-09-09T04:22:17Z'),
+          hostname: 'localhost', tags: ['foo'], message: 'bar')
+      end
+    end
+
+    def test_event_compatibility
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz") }
+      assert_equal_datagrams { |client| client.event('foo', "bar\nbaz", no_prefix: true) }
+      assert_equal_datagrams do |client|
+        client.event('Something happend', "And it's not good", timestamp: Time.parse('2019-09-09T04:22:17Z'),
+          hostname: 'localhost', tags: ['foo'], alert_type: 'warning', priority: 'low',
+          aggregation_key: 'foo', source_type_name: 'logs')
+      end
+    end
+
+    private
+
+    MODES = [:normal, :with_prefix, :with_default_tags]
+
+    def assert_equal_datagrams(&block)
+      MODES.each do |mode|
+        legacy_datagram = with_legacy_client(mode) { |client| read_datagram(client, &block) }
+        new_datagram = with_new_client(mode) { |client| read_datagram(client, &block) }
+
+        assert_equal legacy_datagram, new_datagram, "The datagrams emitted were not the same in #{mode} mode"
+      end
+    end
+
+    def with_legacy_client(mode)
+      old_prefix = StatsD.prefix
+      StatsD.prefix = 'prefix' if mode == :with_prefix
+
+      old_default_tags = StatsD.default_tags
+      StatsD.default_tags = { key: 'value' } if mode == :with_default_tags
+
+      old_backend = StatsD.backend
+      new_backend = StatsD::Instrument::Backends::UDPBackend.new("#{@host}:#{@port}", :datadog)
+      StatsD.backend = new_backend
+
+      yield(StatsD)
+    ensure
+      new_backend.socket.close if new_backend&.socket
+      StatsD.backend = old_backend
+      StatsD.prefix = old_prefix
+      StatsD.default_tags = old_default_tags
+    end
+
+    def with_new_client(mode)
+      prefix = mode == :with_prefix ? 'prefix' : nil
+      default_tags = mode == :with_default_tags ? { key: 'value' } : nil
+      client = StatsD::Instrument::Client.new(
+        sink: StatsD::Instrument::UDPSink.new(@host, @port),
+        datagram_builder_class: StatsD::Instrument::DogStatsDDatagramBuilder,
+        prefix: prefix,
+        default_tags: default_tags
+      )
+
+      yield(client)
+    end
+
+    def read_datagram(client)
+      yield(client)
+      data, _origin = @server.recvfrom(100)
+      data
+    end
+  end
+end

data/test/datagram_builder_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class DatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::DatagramBuilder.new
+  end
+
+  def test_normalize_name
+    assert_equal 'foo', @datagram_builder.send(:normalize_name, 'foo')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo|o')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo@o')
+    assert_equal 'fo_o', @datagram_builder.send(:normalize_name, 'fo:o')
+  end
+
+  def test_normalize_unsupported_tag_names
+    assert_equal ['ignored'], @datagram_builder.send(:normalize_tags, ['igno|re,d'])
+    # Note: how this is interpreted by the backend is undefined.
+    # We rely on the user to not do stuff like this if they don't want to be surprised.
+    # We do not want to take the performance hit of normaling this.
+    assert_equal ['lol::class:omg::lol'], @datagram_builder.send(:normalize_tags, "lol::class" => "omg::lol")
+  end
+
+  def test_normalize_tags_converts_hash_to_array
+    assert_equal ['tag:value'], @datagram_builder.send(:normalize_tags, tag: 'value')
+    assert_equal ['tag1:v1', 'tag2:v2'], @datagram_builder.send(:normalize_tags, tag1: 'v1', tag2: 'v2')
+  end
+
+  def test_c
+    datagram = @datagram_builder.c('foo', 1, nil, nil)
+    assert_equal "foo:1|c", datagram
+
+    datagram = @datagram_builder.c('fo:o', 10, 0.1, nil)
+    assert_equal "fo_o:10|c|@0.1", datagram
+  end
+
+  def test_ms
+    datagram = @datagram_builder.ms('foo', 1, nil, nil)
+    assert_equal "foo:1|ms", datagram
+
+    datagram = @datagram_builder.ms('fo:o', 10, 0.1, nil)
+    assert_equal "fo_o:10|ms|@0.1", datagram
+  end
+
+  def test_g
+    datagram = @datagram_builder.g('foo', 1, nil, nil)
+    assert_equal "foo:1|g", datagram
+
+    datagram = @datagram_builder.g('fo|o', 10, 0.01, nil)
+    assert_equal "fo_o:10|g|@0.01", datagram
+  end
+
+  def test_s
+    datagram = @datagram_builder.s('foo', 1, nil, nil)
+    assert_equal "foo:1|s", datagram
+
+    datagram = @datagram_builder.s('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|s|@0.01", datagram
+  end
+
+  def test_h
+    datagram = @datagram_builder.h('foo', 1, nil, nil)
+    assert_equal "foo:1|h", datagram
+
+    datagram = @datagram_builder.h('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|h|@0.01", datagram
+  end
+
+  def test_d
+    datagram = @datagram_builder.d('foo', 1, nil, nil)
+    assert_equal "foo:1|d", datagram
+
+    datagram = @datagram_builder.d('fo@o', 10, 0.01, nil)
+    assert_equal "fo_o:10|d|@0.01", datagram
+  end
+
+  def test_tags
+    datagram = @datagram_builder.d('foo', 10, nil, ['foo', 'bar'])
+    assert_equal "foo:10|d|#foo,bar", datagram
+
+    datagram = @datagram_builder.d('foo', 10, 0.1, ['foo:bar'])
+    assert_equal "foo:10|d|@0.1|#foo:bar", datagram
+
+    datagram = @datagram_builder.d('foo', 10, 1, foo: 'bar', baz: 'quc')
+    assert_equal "foo:10|d|#foo:bar,baz:quc", datagram
+  end
+
+  def test_prefix
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(prefix: 'foo')
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'foo.bar:1|c', datagram
+
+    # The prefix should also be normalized
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(prefix: 'foo|bar')
+    datagram = datagram_builder.c('baz', 1, nil, nil)
+    assert_equal 'foo_bar.baz:1|c', datagram
+  end
+
+  def test_default_tags
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(default_tags: ['foo'])
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'bar:1|c|#foo', datagram
+
+    datagram = datagram_builder.c('bar', 1, nil, a: 'b')
+    assert_equal 'bar:1|c|#a:b,foo', datagram
+
+    # We do not filter out duplicates, because detecting dupes is too time consuming.
+    # We let the server deal with the situation
+    datagram = datagram_builder.c('bar', 1, nil, ['foo'])
+    assert_equal 'bar:1|c|#foo,foo', datagram
+
+    # Default tags are also normalized
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(default_tags: ['f,o|o'])
+    datagram = datagram_builder.c('bar', 1, nil, nil)
+    assert_equal 'bar:1|c|#foo', datagram
+  end
+end

data/test/deprecations_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DeprecationsTest < Minitest::Test
+  unless StatsD::Instrument.strict_mode_enabled?
+    class InstrumentedClass
+      extend StatsD::Instrument
+      def foo; end
+      statsd_count :foo, 'frequency', 0.5, ['tag'] # rubocop:disable StatsD/MetaprogrammingPositionalArguments
+      statsd_measure :foo, 'latency', as_dist: true # rubocop:disable StatsD/MeasureAsDistArgument
+      statsd_count_success :foo, 'frequency', prefix: 'foo' # rubocop:disable StatsD/MetricPrefixArgument
+    end
+  end
+
+  include StatsD::Instrument::Assertions
+
+  def setup
+    skip("Deprecation are not supported in strict mode") if StatsD::Instrument.strict_mode_enabled?
+  end
+
+  def test__deprecated__metaprogramming_method_with_positional_arguments
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[0]
+    assert_equal :c, metric.type
+    assert_equal 'frequency', metric.name
+    assert_equal 1, metric.value
+    assert_equal 0.5, metric.sample_rate
+    assert_equal ["tag"], metric.tags
+  end
+
+  def test__deprecated__metaprogramming_statsd_measure_with_as_dist
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[1]
+    assert_equal :d, metric.type
+    assert_equal 'latency', metric.name
+  end
+
+  def test__deprecated__metaprogramming_statsd_count_with_prefix
+    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
+    metric = metrics[2]
+    assert_equal :c, metric.type
+    assert_equal 'foo.frequency.success', metric.name
+  end
+
+  # rubocop:disable StatsD/MetricValueKeywordArgument
+  def test__deprecated__statsd_measure_with_explicit_value_as_keyword_argument
+    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42) }
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
+  end
+
+  # rubocop:disable StatsD/MeasureAsDistArgument
+  def test__deprecated__statsd_measure_with_explicit_value_keyword_and_distribution_override
+    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42, as_dist: true) }
+    assert_equal 42, metric.value
+    assert_equal :d, metric.type
+  end
+  # rubocop:enable StatsD/MeasureAsDistArgument
+
+  def test__deprecated__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__deprecated__statsd_gauge_with_keyword_argument
+    metric = capture_statsd_call { StatsD.gauge('values.foobar', value: 13) }
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 13, metric.value
+  end
+  # rubocop:enable StatsD/MetricValueKeywordArgument
+
+  # rubocop:disable StatsD/MetricReturnValue
+  def test__deprecated__statsd_increment_retuns_metric_instance
+    metric = StatsD.increment('key')
+    assert_kind_of StatsD::Instrument::Metric, metric
+    assert_equal 'key', metric.name
+    assert_equal :c, metric.type
+    assert_equal 1, metric.value
+  end
+  # rubocop:enable StatsD/MetricReturnValue
+
+  # rubocop:disable StatsD/PositionalArguments
+  def test__deprecated__statsd_increment_with_positional_argument_for_tags
+    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
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+  end
+  # rubocop:enable StatsD/PositionalArguments
+
+  # rubocop:disable StatsD/MeasureAsDistArgument
+  def test__deprecated__statsd_measure_with_explicit_value_and_distribution_override
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, as_dist: true) }
+    assert_equal :d, metric.type
+  end
+
+  def test__deprecated__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__deprecated__statsd_measure_as_distribution_returns_return_value_of_block_even_if_nil
+    return_value = StatsD.measure('values.foobar', as_dist: true) { nil }
+    assert_nil return_value
+  end
+  # rubocop:enable StatsD/MeasureAsDistArgument
+
+  # rubocop:disable StatsD/MetricPrefixArgument
+  def test__deprecated__override_name_prefix
+    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar") }
+    assert_equal 'foobar.counter', m.name
+
+    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar", no_prefix: true) }
+    assert_equal 'counter', m.name
+  end
+  # rubocop:enable StatsD/MetricPrefixArgument
+
+  protected
+
+  def capture_statsd_call(&block)
+    metrics = capture_statsd_calls(&block)
+    assert_equal 1, metrics.length
+    metrics.first
+  end
+end