statsd-instrument 2.9.2 → 3.0.0.pre1

data/test/assertions_on_legacy_client_test.rb

@@ -1,344 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class AssertionsOnLegacyClientTest < Minitest::Test
-  def setup
-    @old_client = StatsD.singleton_client
-    StatsD.singleton_client = StatsD.legacy_singleton_client
-
-    test_class = Class.new(Minitest::Test)
-    test_class.send(:include, StatsD::Instrument::Assertions)
-    @test_case = test_class.new('fake')
-  end
-
-  def teardown
-    StatsD.singleton_client = @old_client
-  end
-
-  def test_assert_no_statsd_calls
-    @test_case.assert_no_statsd_calls('counter') do
-      # noop
-    end
-
-    @test_case.assert_no_statsd_calls('counter') do
-      StatsD.increment('other')
-    end
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls('counter') do
-        StatsD.increment('counter')
-      end
-    end
-    assert_equal assertion.message, "No StatsD calls for metric counter expected."
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls do
-        StatsD.increment('other')
-      end
-    end
-    assert_equal assertion.message, "No StatsD calls for metric other expected."
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls do
-        StatsD.increment('other')
-        StatsD.increment('another')
-      end
-    end
-    assert_equal assertion.message, "No StatsD calls for metric other, another expected."
-  end
-
-  def test_assert_statsd_call
-    @test_case.assert_statsd_increment('counter') do
-      StatsD.increment('counter')
-    end
-
-    @test_case.assert_statsd_increment('counter') do
-      StatsD.increment('counter')
-      StatsD.increment('other')
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('other')
-      end
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.gauge('counter', 42)
-      end
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('counter')
-        StatsD.increment('counter')
-      end
-    end
-
-    @test_case.assert_statsd_increment('counter', times: 2) do
-      StatsD.increment('counter')
-      StatsD.increment('counter')
-    end
-
-    @test_case.assert_statsd_increment('counter', times: 2, tags: ['foo:1']) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', times: 2, tags: ['foo:1']) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
-      end
-    end
-
-    @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
-      StatsD.increment('counter', sample_rate: 0.5, tags: ['a', 'b'])
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
-        StatsD.increment('counter', sample_rate: 0.2, tags: ['c'])
-      end
-    end
-  end
-
-  def test_assert_statsd_gauge_call_with_numeric_value
-    @test_case.assert_statsd_gauge('gauge', value: 42) do
-      StatsD.gauge('gauge', 42)
-    end
-
-    @test_case.assert_statsd_gauge('gauge', value: '42') do
-      StatsD.gauge('gauge', 42)
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_gauge('gauge', value: 42) do
-        StatsD.gauge('gauge', 45)
-      end
-    end
-  end
-
-  def test_assert_statsd_set_call_with_string_value
-    @test_case.assert_statsd_set('set', value: 12345) do
-      StatsD.set('set', '12345')
-    end
-
-    @test_case.assert_statsd_set('set', value: '12345') do
-      StatsD.set('set', '12345')
-    end
-
-    @test_case.assert_statsd_set('set', value: 12345) do
-      StatsD.set('set', 12345)
-    end
-
-    @test_case.assert_statsd_set('set', value: '12345') do
-      StatsD.set('set', 12345)
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_set('set', value: '42') do
-        StatsD.set('set', 45)
-      end
-    end
-  end
-
-  def test_tags_will_match_subsets
-    @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1 }) do
-      StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2 })
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1, b: 3 }) do
-        StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2, c: 4 })
-      end
-    end
-  end
-
-  def test_tags_friendly_error
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', tags: { class: "AnotherJob" }) do
-        StatsD.increment('counter', tags: { class: "MyJob" })
-      end
-    end
-
-    assert_includes assertion.message, "Captured metrics with the same key"
-    assert_includes assertion.message, "MyJob"
-  end
-
-  def test_multiple_metrics_are_not_order_dependent
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-    end
-
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-    end
-
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-    end
-
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-    end
-
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-      StatsD.increment('counter', tags: { foo: 1 })
-    end
-  end
-
-  def test_assert_multiple_statsd_calls
-    assert_raises(Minitest::Assertion) do
-      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
-      end
-    end
-
-    assert_raises(Minitest::Assertion) do
-      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
-        StatsD.increment('counter', tags: { foo: 2 })
-      end
-    end
-
-    foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
-    @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-    end
-  end
-
-  def test_assert_statsd_call_with_tags
-    @test_case.assert_statsd_increment('counter', tags: ['a:b', 'c:d']) do
-      StatsD.increment('counter', tags: { a: 'b', c: 'd' })
-    end
-
-    @test_case.assert_statsd_increment('counter', tags: { a: 'b', c: 'd' }) do
-      StatsD.increment('counter', tags: ['a:b', 'c:d'])
-    end
-  end
-
-  def test_nested_assertions
-    @test_case.assert_statsd_increment('counter1') do
-      @test_case.assert_statsd_increment('counter2') do
-        StatsD.increment('counter1')
-        StatsD.increment('counter2')
-      end
-    end
-
-    @test_case.assert_statsd_increment('counter1') do
-      StatsD.increment('counter1')
-      @test_case.assert_statsd_increment('counter2') do
-        StatsD.increment('counter2')
-      end
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter1') do
-        @test_case.assert_statsd_increment('counter2') do
-          StatsD.increment('counter2')
-        end
-      end
-    end
-
-    assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter1') do
-        @test_case.assert_statsd_increment('counter2') do
-          StatsD.increment('counter1')
-        end
-        StatsD.increment('counter2')
-      end
-    end
-  end
-
-  def test_assertion_block_with_expected_exceptions
-    @test_case.assert_statsd_increment('expected_happened') do
-      @test_case.assert_raises(RuntimeError) do
-        begin
-          raise "expected"
-        rescue
-          StatsD.increment('expected_happened')
-          raise
-        end
-      end
-    end
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        @test_case.assert_raises(RuntimeError) do
-          raise "expected"
-        end
-      end
-    end
-    assert_includes assertion.message, "No StatsD calls for metric counter of type c were made"
-  end
-
-  def test_assertion_block_with_unexpected_exceptions
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('counter')
-        raise "unexpected"
-      end
-    end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_raises(RuntimeError) do
-        @test_case.assert_statsd_increment('counter') do
-          StatsD.increment('counter')
-          raise "unexpected"
-        end
-      end
-    end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_raises(RuntimeError) do
-        @test_case.assert_no_statsd_calls do
-          raise "unexpected"
-        end
-      end
-    end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
-  end
-
-  def test_assertion_block_with_other_assertion_failures
-    # If another assertion failure happens inside the block, that failure should have priority
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        @test_case.flunk('other assertion failure')
-      end
-    end
-    assert_equal "other assertion failure", assertion.message
-  end
-end

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