statsd-instrument 2.9.2 → 3.0.0.pre1

data/lib/statsd/instrument/helpers.rb

@@ -3,38 +3,9 @@
 module StatsD::Instrument::Helpers
   def capture_statsd_datagrams(client: nil, &block)
     client ||= StatsD.singleton_client
-    case client
-    when StatsD.legacy_singleton_client
-      capture_statsd_metrics_on_legacy_client(&block)
-    when StatsD::Instrument::Client
-      client.capture(&block)
-    else
-      raise ArgumentError, "Don't know how to capture StatsD datagrams from #{client.inspect}!"
-    end
+    client.capture(&block)
   end
 
   # For backwards compatibility
   alias_method :capture_statsd_calls, :capture_statsd_datagrams
-
-  def capture_statsd_metrics_on_legacy_client(&block)
-    capture_backend = StatsD::Instrument::Backends::CaptureBackend.new
-    with_capture_backend(capture_backend, &block)
-    capture_backend.collected_metrics
-  end
-
-  private
-
-  def with_capture_backend(backend)
-    if StatsD.legacy_singleton_client.backend.is_a?(StatsD::Instrument::Backends::CaptureBackend)
-      backend.parent = StatsD.legacy_singleton_client.backend
-    end
-
-    old_backend = StatsD.legacy_singleton_client.backend
-    begin
-      StatsD.legacy_singleton_client.backend = backend
-      yield
-    ensure
-      StatsD.legacy_singleton_client.backend = old_backend
-    end
-  end
 end

data/lib/statsd/instrument/railtie.rb

@@ -8,8 +8,4 @@ class StatsD::Instrument::Railtie < Rails::Railtie
   initializer 'statsd-instrument.use_rails_logger' do
     ::StatsD.logger = Rails.logger
   end
-
-  initializer 'statsd-instrument.setup_backend', after: 'statsd-instrument.use_rails_logger' do
-    ::StatsD.backend = ::StatsD::Instrument::Environment.default_backend
-  end
 end

data/lib/statsd/instrument/strict.rb

@@ -55,9 +55,7 @@ module StatsD
         super
       end
 
-      def service_check(name, status, tags: nil, no_prefix: false,
-        hostname: nil, timestamp: nil, message: nil)
-
+      def service_check(name, status, tags: nil, no_prefix: false, hostname: nil, timestamp: nil, message: nil)
         super
       end
 
@@ -106,133 +104,30 @@ module StatsD
       end
     end
 
-    module VoidCollectMetric
-      protected
-
-      def collect_metric(type, name, value, sample_rate:, tags: nil, prefix:, metadata: nil)
-        super
-        StatsD::Instrument::VOID
-      end
-    end
-
     module StrictMetaprogramming
-      def statsd_measure(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_measure(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.measure call to not use the `as_dist` and `prefix` arguments.
-        add_to_method(method, name, :measure) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.measure(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
-              super(*args, &block)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_distribution(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_distribution(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.distribution call to not use the `prefix` argument.
-
-        add_to_method(method, name, :distribution) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.distribution(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
-              super(*args, &block)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count_success(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count_success(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count_success) do
-          define_method(method) do |*args, &block|
-            begin
-              truthiness = result = super(*args, &block)
-            rescue
-              truthiness = false
-              raise
-            else
-              if block_given?
-                begin
-                  truthiness = yield(result)
-                rescue
-                  truthiness = false
-                end
-              end
-              result
-            ensure
-              suffix = truthiness == false ? 'failure' : 'success'
-              key = "#{StatsD::Instrument.generate_metric_name(nil, name, self, *args)}.#{suffix}"
-              client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count_if(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count_if(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count_if) do
-          define_method(method) do |*args, &block|
-            begin
-              truthiness = result = super(*args, &block)
-            rescue
-              truthiness = false
-              raise
-            else
-              if block_given?
-                begin
-                  truthiness = yield(result)
-                rescue
-                  truthiness = false
-                end
-              end
-              result
-            ensure
-              if truthiness
-                key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-                client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-              end
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-            super(*args, &block)
-          end
-        end
+        super
       end
 
       private
@@ -250,6 +145,5 @@ module StatsD
   end
 end
 
-StatsD.singleton_class.prepend(StatsD::Instrument::Strict)
-StatsD::Instrument::LegacyClient.prepend(StatsD::Instrument::VoidCollectMetric)
+StatsD::Instrument::Client.prepend(StatsD::Instrument::Strict)
 StatsD::Instrument.prepend(StatsD::Instrument::StrictMetaprogramming)

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "2.9.2"
+    VERSION = "3.0.0.pre1"
   end
 end

data/test/assertions_test.rb

@@ -132,55 +132,43 @@ class AssertionsTest < Minitest::Test
   end
 
   def test_assert_statsd_gauge_call_with_numeric_value
-    @test_case.assert_statsd_gauge('gauge', 42) do
+    @test_case.assert_statsd_gauge('gauge', value: 42) do
       StatsD.gauge('gauge', 42)
     end
 
-    @test_case.assert_statsd_gauge('gauge', '42') do
+    @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', 42) do
+      @test_case.assert_statsd_gauge('gauge', value: 42) do
         StatsD.gauge('gauge', 45)
       end
     end
-
-    @test_case.assert_statsd_gauge('gauge', value: 42) do
-      StatsD.gauge('gauge', 42)
-    end
   end
 
   def test_assert_statsd_set_call_with_string_value
-    @test_case.assert_statsd_set('set', 12345) do
+    @test_case.assert_statsd_set('set', value: 12345) do
       StatsD.set('set', '12345')
     end
 
-    @test_case.assert_statsd_set('set', '12345') do
+    @test_case.assert_statsd_set('set', value: '12345') do
       StatsD.set('set', '12345')
     end
 
-    @test_case.assert_statsd_set('set', 12345) do
+    @test_case.assert_statsd_set('set', value: 12345) do
       StatsD.set('set', 12345)
     end
 
-    @test_case.assert_statsd_set('set', '12345') do
+    @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', '42') do
+      @test_case.assert_statsd_set('set', value: '42') do
         StatsD.set('set', 45)
       end
     end
-
-    @test_case.assert_statsd_set('set', value: 12345) do
-      StatsD.set('set', '12345')
-    end
-
-    @test_case.assert_statsd_set('set', 'wrong_value', value: 12345) do
-      StatsD.set('set', '12345')
-    end
   end
 
   def test_tags_will_match_subsets
@@ -297,7 +285,7 @@ class AssertionsTest < Minitest::Test
     end
 
     foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', 1, tags: ['foo:2'])
+    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 })

data/test/client_test.rb

@@ -186,6 +186,17 @@ class ClientTest < Minitest::Test
     assert_equal "bar", datagrams[1].name
   end
 
+  def test_default_tags_normalization
+    client = StatsD::Instrument::Client.new(default_tags: { first_tag: 'f|irst_value', second_tag: 'sec,ond_value' })
+    datagrams = client.capture do
+      client.increment('bar', tags: ['th|ird_#,tag'])
+    end
+
+    assert_includes datagrams.first.tags, 'first_tag:first_value'
+    assert_includes datagrams.first.tags, 'second_tag:second_value'
+    assert_includes datagrams.first.tags, 'third_#tag'
+  end
+
   def test_sampling
     mock_sink = mock('sink')
     mock_sink.stubs(:sample?).returns(false, true, false, false, true)

data/test/environment_test.rb

@@ -5,37 +5,6 @@ require 'test_helper'
 module Rails; end
 
 class EnvironmentTest < Minitest::Test
-  def setup
-    ENV['STATSD_ADDR'] = nil
-    ENV['IMPLEMENTATION'] = nil
-  end
-
-  def test_default_backend_uses_logger_in_development_environment
-    StatsD::Instrument::Environment.stubs(:environment).returns('development')
-    assert_instance_of StatsD::Instrument::Backends::LoggerBackend, StatsD::Instrument::Environment.default_backend
-  end
-
-  def test_default_backend_uses_null_backend_in_test_environment
-    StatsD::Instrument::Environment.stubs(:environment).returns('test')
-    assert_instance_of StatsD::Instrument::Backends::NullBackend, StatsD::Instrument::Environment.default_backend
-  end
-
-  def test_default_backend_uses_udp_backend_in_production_environment
-    StatsD::Instrument::Environment.stubs(:environment).returns('production')
-    assert_instance_of StatsD::Instrument::Backends::UDPBackend, StatsD::Instrument::Environment.default_backend
-  end
-
-  def test_default_backend_uses_environment_variables_in_production_environment
-    StatsD::Instrument::Environment.stubs(:environment).returns('production')
-    ENV['STATSD_ADDR'] = '127.0.0.1:1234'
-    ENV['STATSD_IMPLEMENTATION'] = 'datadog'
-
-    backend = StatsD::Instrument::Environment.default_backend
-    assert_equal '127.0.0.1', backend.host
-    assert_equal 1234, backend.port
-    assert_equal :datadog, backend.implementation
-  end
-
   def test_environment_prefers_statsd_env_if_available
     env = StatsD::Instrument::Environment.new(
       'STATSD_ENV' => 'set_from_STATSD_ENV',
@@ -62,13 +31,8 @@ class EnvironmentTest < Minitest::Test
     assert_equal 'development', env.environment
   end
 
-  def test_legacy_client_is_default_client
+  def test_client_returns_client_instance
     env = StatsD::Instrument::Environment.new({})
-    assert_kind_of StatsD::Instrument::LegacyClient, env.client
-  end
-
-  def test_client_returns_new_client_if_environment_asks_for_it
-    env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1')
     assert_kind_of StatsD::Instrument::Client, env.client
   end
 

data/test/integration_test.rb

@@ -6,39 +6,24 @@ class IntegrationTest < Minitest::Test
   def setup
     @server = UDPSocket.new
     @server.bind('localhost', 0)
-    port = @server.addr[1]
 
-    @old_backend = StatsD.backend
-    StatsD.backend = StatsD::Instrument::Backends::UDPBackend.new("localhost:#{port}")
+    @env = StatsD::Instrument::Environment.new(
+      'STATSD_ADDR' => "#{@server.addr[2]}:#{@server.addr[1]}",
+      'STATSD_IMPLEMENTATION' => 'dogstatsd',
+      'STATSD_ENV' => 'production',
+    )
+
+    @old_client = StatsD.singleton_client
+    StatsD.singleton_client = @env.client
   end
 
   def teardown
+    StatsD.singleton_client = @old_client
     @server.close
-    StatsD.backend = @old_backend
   end
 
   def test_live_local_udp_socket
     StatsD.increment('counter')
     assert_equal "counter:1|c", @server.recvfrom(100).first
   end
-
-  def test_synchronize_in_exit_handler_handles_thread_error_and_exits_cleanly
-    pid = fork do
-      Signal.trap('TERM') do
-        StatsD.increment('exiting')
-        Process.exit!(0)
-      end
-
-      sleep 100
-    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", @server.recvfrom_nonblock(100).first
-
-  rescue NotImplementedError
-    pass("Fork is not implemented on #{RUBY_PLATFORM}")
-  end
 end

data/test/statsd_instrumentation_test.rb

@@ -326,30 +326,42 @@ class StatsDInstrumentationTest < Minitest::Test
   end
 
   def test_statsd_respects_global_prefix_changes
-    StatsD.prefix = 'Foo'
+    old_client = StatsD.singleton_client
+
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: 'Foo')
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
     ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
-    StatsD.prefix = 'Quc'
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: 'Quc')
 
-    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, statsd_calls.length
-    assert_equal "Quc.ActiveMerchant.Gateway.sync", statsd_calls.first.name
+    datagrams = capture_statsd_calls { ActiveMerchant::Gateway.sync }
+    assert_equal 1, datagrams.length
+    assert_equal "Quc.ActiveMerchant.Gateway.sync", datagrams.first.name
   ensure
-    StatsD.prefix = nil
+    StatsD.singleton_client = old_client
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end
 
+  def test_statsd_count_with_injected_client
+    client = StatsD::Instrument::Client.new(prefix: 'prefix')
+
+    ActiveMerchant::Gateway.statsd_count(:ssl_post, 'ActiveMerchant.Gateway.ssl_post', client: client)
+    assert_statsd_increment('prefix.ActiveMerchant.Gateway.ssl_post', client: client) do
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
+  ensure
+    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+  end
+
   def test_statsd_macro_can_disable_prefix
-    StatsD.prefix = 'Foo'
+    client = StatsD::Instrument::Client.new(prefix: 'foo')
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count_success :sync, 'ActiveMerchant.Gateway.sync', no_prefix: true
-    StatsD.prefix = 'Quc'
+    ActiveMerchant::Gateway.singleton_class.statsd_count_success(:sync,
+      'ActiveMerchant.Gateway.sync', no_prefix: true, client: client)
 
-    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, statsd_calls.length
-    assert_equal "ActiveMerchant.Gateway.sync.success", statsd_calls.first.name
+    datagrams = client.capture { ActiveMerchant::Gateway.sync }
+    assert_equal 1, datagrams.length
+    assert_equal "ActiveMerchant.Gateway.sync.success", datagrams.first.name
   ensure
-    StatsD.prefix = nil
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count_success :sync, 'ActiveMerchant.Gateway.sync'
   end
 
@@ -417,43 +429,6 @@ class StatsDInstrumentationTest < Minitest::Test
     end
   end
 
-  def test_statsd_measure_with_new_client
-    old_client = StatsD.singleton_client
-    StatsD.singleton_client = StatsD::Instrument::Client.new
-
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-    StatsD.singleton_client = old_client
-  end
-
-  def test_statsd_count_with_new_client
-    old_client = StatsD.singleton_client
-    StatsD.singleton_client = StatsD::Instrument::Client.new
-
-    ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-    assert_statsd_increment('ActiveMerchant.Gateway.ssl_post') do
-      ActiveMerchant::Gateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-    StatsD.singleton_client = old_client
-  end
-
-  def test_statsd_count_with_injected_client
-    client = StatsD::Instrument::Client.new(prefix: 'prefix')
-
-    ActiveMerchant::Gateway.statsd_count(:ssl_post, 'ActiveMerchant.Gateway.ssl_post', client: client)
-    assert_statsd_increment('prefix.ActiveMerchant.Gateway.ssl_post', client: client) do
-      ActiveMerchant::Gateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
   private
 
   def assert_scope(klass, method, expected_scope)