statsd-instrument 2.6.0 → 2.7.0

data/test/assertions_test.rb

@@ -4,11 +4,19 @@ require 'test_helper'
 
 class AssertionsTest < Minitest::Test
   def setup
+    @old_client = StatsD.singleton_client
+    env = StatsD::Instrument::Environment.new('STATSD_IMPLEMENTATION' => 'datadog')
+    StatsD.singleton_client = env.default_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
@@ -41,7 +49,7 @@ class AssertionsTest < Minitest::Test
     assert_equal assertion.message, "No StatsD calls for metric other, another expected."
   end
 
-  def test_assert_statsd_call
+  def test_assert_statsd
     @test_case.assert_statsd_increment('counter') do
       StatsD.increment('counter')
     end
@@ -130,6 +138,46 @@ class AssertionsTest < Minitest::Test
     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 })
@@ -153,60 +201,89 @@ class AssertionsTest < Minitest::Test
     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
+  def test_capture_and_assert
+    datagrams = @test_case.capture_statsd_datagrams do
+      StatsD.increment('counter', tags: { foo: 1 })
+      StatsD.increment('counter', tags: { foo: 2 })
+    end
+
+    @test_case.assert_statsd_increment('counter', tags: ['foo:1'], datagrams: datagrams)
+    @test_case.assert_statsd_increment('counter', tags: ['foo:2'], datagrams: datagrams)
+  end
+
+  def test_capture_from_different_client
+    client = StatsD::Instrument::Client.new
+    @test_case.assert_statsd_increment('foo', client: client) do
+      client.increment('foo')
+    end
+
+    assert_raises(Minitest::Assertion) do
+      @test_case.assert_statsd_increment('foo', client: client) do
+        StatsD.increment('foo')
+      end
+    end
+
+    assert_raises(Minitest::Assertion) do
+      @test_case.assert_statsd_increment('foo') do
+        client.increment('foo')
+      end
+    end
+  end
+
+  def test_multiple_expectations_are_not_order_dependent
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+  def test_assert_multiple_statsd_expectations
     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
+      foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+      @test_case.assert_statsd_expectations([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
+      foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+      @test_case.assert_statsd_expectations([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 })
@@ -214,16 +291,16 @@ class AssertionsTest < Minitest::Test
       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
+    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
+    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    @test_case.assert_statsd_expectations([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
+  def test_assert_statsd_increment_with_tags
     @test_case.assert_statsd_increment('counter', tags: ['a:b', 'c:d']) do
       StatsD.increment('counter', tags: { a: 'b', c: 'd' })
     end
@@ -233,17 +310,6 @@ class AssertionsTest < Minitest::Test
     end
   end
 
-  def test_assert_statsd_call_with_wrong_sample_rate_type
-    skip("In Strict mode, the StatsD.increment call will raise") if StatsD::Instrument.strict_mode_enabled?
-
-    assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', tags: ['a', 'b']) do
-        StatsD.increment('counter', sample_rate: 'abc', tags: ['a', 'b'])
-      end
-    end
-    assert_equal "Unexpected sample rate type for metric counter, must be numeric", assertion.message
-  end
-
   def test_nested_assertions
     @test_case.assert_statsd_increment('counter1') do
       @test_case.assert_statsd_increment('counter2') do

data/test/capture_sink_test.rb

@@ -2,8 +2,6 @@
 
 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: [])

data/test/client_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class ClientTest < Minitest::Test
   def setup
     @client = StatsD::Instrument::Client.new(datagram_builder_class: StatsD::Instrument::StatsDDatagramBuilder)

data/test/compatibility/dogstatsd_datagram_compatibility_test.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/client'
 
 module Compatibility
   class DogStatsDDatagramCompatibilityTest < Minitest::Test

data/test/datagram_builder_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class DatagramBuilderTest < Minitest::Test
   def setup
     @datagram_builder = StatsD::Instrument::DatagramBuilder.new
@@ -17,7 +15,7 @@ class DatagramBuilderTest < Minitest::Test
   end
 
   def test_normalize_unsupported_tag_names
-    assert_equal ['ignored'], @datagram_builder.send(:normalize_tags, ['igno|re,d'])
+    assert_equal ['ign#ored'], @datagram_builder.send(:normalize_tags, ['ign#o|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.

data/test/datagram_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DatagramTest < Minitest::Test
+  def test_parsing_datagrams
+    datagram = 'Kernel.Orders.order_creation_path:1|c|' \
+      '#order_source:web,code_source:NilController#NilAction,order_builder:false,' \
+      'multi_currency:false,fulfillment_orders_beta_enabled:false'
+
+    parsed = StatsD::Instrument::Datagram.new(datagram)
+    assert_includes parsed.tags, 'code_source:NilController#NilAction'
+  end
+end

data/test/dogstatsd_datagram_builder_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class DogStatsDDatagramBuilderTest < Minitest::Test
   def setup
     @datagram_builder = StatsD::Instrument::DogStatsDDatagramBuilder.new

data/test/environment_test.rb

@@ -103,7 +103,7 @@ class EnvironmentTest < Minitest::Test
   def test_default_client_has_sensible_defaults
     env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'production')
 
-    assert_equal StatsD::Instrument::StatsDDatagramBuilder, env.default_client.datagram_builder_class
+    assert_equal StatsD::Instrument::DogStatsDDatagramBuilder, env.default_client.datagram_builder_class
     assert_equal 'localhost', env.default_client.sink.host
     assert_equal 8125, env.default_client.sink.port
     assert_equal 1.0, env.default_client.default_sample_rate

data/test/helpers_test.rb

@@ -22,4 +22,21 @@ class HelpersTest < Minitest::Test
     assert_equal 'gauge', metrics[1].name
     assert_equal 12, metrics[1].value
   end
+
+  def test_capture_metrics_with_new_client
+    @old_client = StatsD.singleton_client
+    StatsD.singleton_client = StatsD.client
+
+    StatsD.increment('counter')
+    metrics = @test_case.capture_statsd_datagrams do
+      StatsD.increment('counter')
+      StatsD.gauge('gauge', 12)
+    end
+    StatsD.gauge('gauge', 15)
+
+    assert_equal 2, metrics.length
+
+  ensure
+    StatsD.singleton_client = @old_client
+  end
 end

data/test/log_sink_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class LogSinktest < Minitest::Test
   def test_log_sink
     logger = Logger.new(log = StringIO.new)

data/test/logger_backend_test.rb

@@ -15,8 +15,8 @@ class LoggerBackendTest < Minitest::Test
     @backend.collect_metric(@metric1)
     @backend.collect_metric(@metric2)
     assert_equal <<~LOG, @io.string
-      [StatsD] increment mock.counter:1 #a:b #c:d
-      [StatsD] measure mock.measure:123 @0.3
+      [StatsD] mock.counter:1|c|#a:b,c:d
+      [StatsD] mock.measure:123|ms|@0.3
     LOG
   end
 end

data/test/metric_test.rb

@@ -36,11 +36,11 @@ class MetricTest < Minitest::Test
   end
 
   def test_default_tags
-    StatsD.stubs(:default_tags).returns(['default_tag:default_value'])
+    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.stubs(:default_tags).returns(['tag:value'])
+    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

data/test/null_sink_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class NullSinktest < Minitest::Test
   def test_null_sink
     null_sink = StatsD::Instrument::NullSink.new

data/test/rubocop/singleton_configuration_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class SingletonConfigurationTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::SingletonConfiguration.new
+    end
+
+    def test_offense_statsd_backend
+      assert_offense('StatsD.backend = "foo"')
+      assert_offense('old_backend = StatsD.backend')
+    end
+
+    def test_offense_statsd_prefix
+      assert_offense('StatsD.prefix = "foo"')
+      assert_offense('"#{StatsD.prefix}.foo"')
+    end
+
+    def test_offense_statsd_default_tags
+      assert_offense('StatsD.default_tags = ["foo"]')
+      assert_offense('StatsD.default_tags.empty?')
+    end
+
+    def test_offense_statsd_default_sample_rate
+      assert_offense('StatsD.default_sample_rate = 1.0')
+      assert_offense('should_sample = StatsD.default_sample_rate > rand')
+    end
+
+    def test_no_offense_for_other_methods
+      assert_no_offenses('StatsD.singleton_client = my_client')
+      assert_no_offenses('StatsD.logger.info("foo")')
+    end
+
+    def test_no_offense_for_constant_reference
+      assert_no_offenses('legacy_client = StatsD')
+    end
+  end
+end

data/test/statsd_datagram_builder_test.rb

@@ -2,8 +2,6 @@
 
 require 'test_helper'
 
-require 'statsd/instrument/client'
-
 class StatsDDatagramBuilderTest < Minitest::Test
   def setup
     @datagram_builder = StatsD::Instrument::StatsDDatagramBuilder.new

data/test/statsd_instrumentation_test.rb

@@ -221,11 +221,10 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
   end
 
-  def test_statsd_measure_yells_without_block
-    err = assert_raises(ArgumentError) do
+  def test_statsd_measure_raises_without_a_provided_block
+    assert_raises(LocalJumpError) do
       assert_statsd_measure('ActiveMerchant.Gateway.ssl_post')
     end
-    assert_equal "block must be given", err.to_s
   end
 
   def test_statsd_measure_with_method_receiving_block
@@ -268,11 +267,10 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
   end
 
-  def test_statsd_distribution_yells_without_block
-    err = assert_raises(ArgumentError) do
+  def test_statsd_distribution_raises_without_a_provided_block
+    assert_raises(LocalJumpError) do
       assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post')
     end
-    assert_equal "block must be given", err.to_s
   end
 
   def test_statsd_distribution_with_method_receiving_block