statsd-instrument 2.9.0 → 3.0.0

data/test/capture_backend_test.rb

@@ -1,26 +0,0 @@
-# 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)
-  end
-
-  def test_collecting_metric
-    assert @backend.collected_metrics.empty?
-    @backend.collect_metric(@metric1)
-    @backend.collect_metric(@metric2)
-    assert_equal [@metric1, @metric2], @backend.collected_metrics
-  end
-
-  def test_reset
-    @backend.collect_metric(@metric1)
-    @backend.reset
-    assert @backend.collected_metrics.empty?
-    @backend.collect_metric(@metric2)
-    assert_equal [@metric2], @backend.collected_metrics
-  end
-end

data/test/compatibility/dogstatsd_datagram_compatibility_test.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-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 happened', "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/deprecations_test.rb

@@ -1,139 +0,0 @@
-# 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_returns_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
-
-  def test__deprecated__statsd_key_value
-    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
-
-  protected
-
-  def capture_statsd_call(&block)
-    metrics = capture_statsd_calls(&block)
-    assert_equal 1, metrics.length
-    metrics.first
-  end
-end

data/test/logger_backend_test.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class LoggerBackendTest < Minitest::Test
-  def setup
-    logger = Logger.new(@io = StringIO.new)
-    logger.formatter = lambda { |_, _, _, msg| "#{msg}\n" }
-    @backend = StatsD::Instrument::Backends::LoggerBackend.new(logger)
-    @metric1 = StatsD::Instrument::Metric.new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd' })
-    @metric2 = StatsD::Instrument::Metric.new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
-  end
-
-  def test_logs_metrics
-    @backend.collect_metric(@metric1)
-    @backend.collect_metric(@metric2)
-    assert_equal <<~LOG, @io.string
-      [StatsD] mock.counter:1|c|#a:b,c:d
-      [StatsD] mock.measure:123|ms|@0.3
-    LOG
-  end
-end

data/test/metric_test.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class MetricTest < Minitest::Test
-  def test_required_arguments
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :c) }
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(name: 'test') }
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :ms, name: 'test') }
-  end
-
-  def test_default_values
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
-    assert_equal 1, m.value
-    assert_equal StatsD.default_sample_rate, m.sample_rate
-    assert m.tags.nil?
-  end
-
-  def test_bad_metric_name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric')
-    assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric')
-    assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric')
-    assert_equal 'my_metric', m.name
-  end
-
-  def test_handle_bad_tags
-    assert_equal ['ignored'], StatsD::Instrument::Metric.normalize_tags(['igno|red'])
-    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags("lol::class" => "omg::lol")
-  end
-
-  def test_rewrite_tags_provided_as_hash
-    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(tag: 'value')
-    assert_equal ['tag1:v1', 'tag2:v2'], StatsD::Instrument::Metric.normalize_tags(tag1: 'v1', tag2: 'v2')
-  end
-
-  def test_default_tags
-    StatsD.legacy_singleton_client.stubs(:default_tags).returns(['default_tag:default_value'])
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
-    assert_equal ['tag:value', 'default_tag:default_value'], m.tags
-
-    StatsD.legacy_singleton_client.stubs(:default_tags).returns(['tag:value'])
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
-    assert_equal ['tag:value', 'tag:value'], m.tags # we don't care about duplicates
-  end
-end

data/test/udp_backend_test.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class UDPBackendTest < Minitest::Test
-  def setup
-    StatsD.legacy_singleton_client.stubs(:backend).returns(@backend = StatsD::Instrument::Backends::UDPBackend.new)
-    @backend.stubs(:rand).returns(0.0)
-
-    UDPSocket.stubs(:new).returns(@socket = mock('socket'))
-    @socket.stubs(:connect)
-    @socket.stubs(:send).returns(1)
-
-    StatsD.stubs(:logger).returns(@logger = mock('logger'))
-  end
-
-  def test_changing_host_or_port_should_create_new_socket
-    @socket.expects(:connect).with('localhost', 1234).once
-    @socket.expects(:connect).with('localhost', 2345).once
-    @socket.expects(:connect).with('127.0.0.1', 2345).once
-
-    @backend.server = "localhost:1234"
-    @backend.socket
-
-    @backend.port = 2345
-    @backend.socket
-
-    @backend.host = '127.0.0.1'
-    @backend.socket
-  end
-
-  def test_collect_respects_sampling_rate
-    @socket.expects(:send).once.returns(1)
-    metric = StatsD::Instrument::Metric.new(type: :c, name: 'test', sample_rate: 0.5)
-
-    @backend.stubs(:rand).returns(0.4)
-    @backend.collect_metric(metric)
-
-    @backend.stubs(:rand).returns(0.6)
-    @backend.collect_metric(metric)
-  end
-
-  def test_support_counter_syntax
-    @backend.expects(:write_packet).with('counter:1|c').once
-    StatsD.increment('counter', sample_rate: 1.0)
-
-    @backend.expects(:write_packet).with('counter:1|c|@0.5').once
-    StatsD.increment('counter', sample_rate: 0.5)
-  end
-
-  def test_supports_gauge_syntax
-    @backend.expects(:write_packet).with('fooy:1.23|g')
-    StatsD.gauge('fooy', 1.23)
-
-    @backend.expects(:write_packet).with('fooy:42|g|@0.01')
-    StatsD.gauge('fooy', 42, sample_rate: 0.01)
-  end
-
-  def test_supports_set_syntax
-    @backend.expects(:write_packet).with('unique:10.0.0.10|s')
-    StatsD.set('unique', '10.0.0.10')
-
-    @backend.expects(:write_packet).with('unique:10.0.0.10|s|@0.01')
-    StatsD.set('unique', '10.0.0.10', sample_rate: 0.01)
-  end
-
-  def test_support_measure_syntax
-    @backend.expects(:write_packet).with('duration:1.23|ms')
-    StatsD.measure('duration', 1.23)
-
-    @backend.expects(:write_packet).with('duration:0.42|ms|@0.01')
-    StatsD.measure('duration', 0.42, sample_rate: 0.01)
-  end
-
-  def test_histogram_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('fooh:42.4|h')
-    StatsD.histogram('fooh', 42.4)
-  end
-
-  def test_distribution_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('fooh:42.4|d')
-    StatsD.distribution('fooh', 42.4)
-  end
-
-  def test_event_on_datadog
-    @backend.implementation = :datadog
-    @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")
-  end
-
-  def test_event_on_datadog_ignores_invalid_metadata
-    @backend.implementation = :datadog
-    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
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.event('fooh', 'bar')
-  end
-
-  def test_service_check_on_datadog
-    @backend.implementation = :datadog
-    @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
-    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
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.service_check('fooh', 'bar')
-  end
-
-  def test_histogram_warns_if_not_using_datadog
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.histogram('fooh', 42.4)
-  end
-
-  def test_distribution_warns_if_not_using_datadog
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.distribution('fooh', 42.4)
-  end
-
-  def test_supports_key_value_syntax_on_statsite
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @backend.implementation = :statsite
-    @backend.expects(:write_packet).with("fooy:42|kv\n")
-    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
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @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
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.key_value('fookv', 3.33)
-  end
-
-  def test_support_tags_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with("fooc:3|c|#topic:foo,bar")
-    StatsD.increment('fooc', 3, tags: ['topic:foo', 'bar'])
-  end
-
-  def test_socket_error_should_not_raise_but_log
-    @socket.stubs(:connect).raises(SocketError)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_system_call_error_should_not_raise_but_log
-    @socket.stubs(:send).raises(Errno::ETIMEDOUT)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_io_error_should_not_raise_but_log
-    @socket.stubs(:send).raises(IOError)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_socket_error_should_invalidate_socket
-    seq = sequence('fail_then_succeed')
-
-    @socket.expects(:connect).with('localhost', 8125)
-    @socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
-
-    @socket.expects(:send).returns(1).in_sequence(seq)
-    @logger.expects(:error)
-
-    StatsD.increment('fail')
-    StatsD.increment('succeed')
-  end
-end