statsd-instrument 2.9.2 → 3.0.2

data/test/datagram_builder_test.rb

@@ -8,111 +8,111 @@ class DatagramBuilderTest < Minitest::Test
   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')
+    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 ['ign#ored'], @datagram_builder.send(:normalize_tags, ['ign#o|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 normalizing this.
-    assert_equal ['lol::class:omg::lol'], @datagram_builder.send(:normalize_tags, "lol::class" => "omg::lol")
+    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')
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    assert_equal('bar:1|c|#foo', datagram)
   end
 end

data/test/datagram_test.rb

@@ -9,6 +9,6 @@ class DatagramTest < Minitest::Test
       'multi_currency:false,fulfillment_orders_beta_enabled:false'
 
     parsed = StatsD::Instrument::Datagram.new(datagram)
-    assert_includes parsed.tags, 'code_source:NilController#NilAction'
+    assert_includes(parsed.tags, 'code_source:NilController#NilAction')
   end
 end

data/test/dogstatsd_datagram_builder_test.rb

@@ -13,55 +13,55 @@ class DogStatsDDatagramBuilderTest < Minitest::Test
 
   def test_simple_service_check
     datagram = @datagram_builder._sc('service', :ok)
-    assert_equal '_sc|service|0', datagram
+    assert_equal('_sc|service|0', datagram)
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 0, parsed_datagram.value
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal('service', parsed_datagram.name)
+    assert_equal(0, parsed_datagram.value)
   end
 
   def test_complex_service_check
     datagram = @datagram_builder._sc('service', :warning, timestamp: Time.parse('2019-09-30T04:22:12Z'),
       hostname: 'localhost', tags: { foo: 'bar|baz' }, message: 'blah')
-    assert_equal "_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram
+    assert_equal("_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 1, parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal 'blah', parsed_datagram.message
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal('service', parsed_datagram.name)
+    assert_equal(1, parsed_datagram.value)
+    assert_equal('localhost', parsed_datagram.hostname)
+    assert_equal(Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal('blah', parsed_datagram.message)
   end
 
   def test_simple_event
     datagram = @datagram_builder._e('hello', "world")
-    assert_equal '_e{5,5}:hello|world', datagram
+    assert_equal('_e{5,5}:hello|world', datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'hello', parsed_datagram.name
-    assert_equal 'world', parsed_datagram.value
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal('hello', parsed_datagram.name)
+    assert_equal('world', parsed_datagram.value)
   end
 
   def test_complex_event
     datagram = @datagram_builder._e("testing", "with\nnewline", timestamp: Time.parse('2019-09-30T04:22:12Z'),
       hostname: 'localhost', aggregation_key: 'my-key', priority: 'low', source_type_name: 'source',
       alert_type: 'success', tags: { foo: 'bar|baz' })
-    assert_equal '_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
-      'p:low|s:source|t:success|#foo:barbaz', datagram
+    assert_equal('_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
+      'p:low|s:source|t:success|#foo:barbaz', datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'testing', parsed_datagram.name
-    assert_equal "with\nnewline", parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal "my-key", parsed_datagram.aggregation_key
-    assert_equal "low", parsed_datagram.priority
-    assert_equal "source", parsed_datagram.source_type_name
-    assert_equal "success", parsed_datagram.alert_type
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal('testing', parsed_datagram.name)
+    assert_equal("with\nnewline", parsed_datagram.value)
+    assert_equal('localhost', parsed_datagram.hostname)
+    assert_equal(Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal("my-key", parsed_datagram.aggregation_key)
+    assert_equal("low", parsed_datagram.priority)
+    assert_equal("source", parsed_datagram.source_type_name)
+    assert_equal("success", parsed_datagram.alert_type)
   end
 end

data/test/environment_test.rb

@@ -5,90 +5,54 @@ 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',
       'RACK_ENV' => 'set_from_RACK_ENV',
       'ENV' => 'set_from_ENV',
     )
-    assert_equal 'set_from_STATSD_ENV', env.environment
+    assert_equal('set_from_STATSD_ENV', env.environment)
   end
 
   def test_environment_uses_env_when_rails_does_not_respond_to_env_and_statsd_env_is_not_set
     env = StatsD::Instrument::Environment.new(
       'ENV' => 'set_from_ENV',
     )
-    assert_equal 'set_from_ENV', env.environment
+    assert_equal('set_from_ENV', env.environment)
   end
 
   def test_environment_uses_rails_env_when_rails_is_available
     Rails.stubs(:env).returns('production')
-    assert_equal 'production', StatsD::Instrument::Environment.environment
+    assert_equal('production', StatsD::Instrument::Environment.environment)
   end
 
   def test_environment_defaults_to_development
     env = StatsD::Instrument::Environment.new({})
-    assert_equal 'development', env.environment
+    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
+    assert_kind_of(StatsD::Instrument::Client, env.client)
   end
 
   def test_client_from_env_uses_log_sink_in_development_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'development')
-    assert_kind_of StatsD::Instrument::LogSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::LogSink, env.client.sink)
   end
 
   def test_client_from_env_uses_null_sink_in_test_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'test')
-    assert_kind_of StatsD::Instrument::NullSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::NullSink, env.client.sink)
   end
 
   def test_client_from_env_uses_udp_sink_in_staging_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'staging')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 
   def test_client_from_env_uses_udp_sink_in_production_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'production')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 end

data/test/helpers/rubocop_helper.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require 'rubocop/cop/legacy/corrector'
 
 module RubocopHelper
   attr_accessor :cop
 
   private
 
+  RUBY_VERSION = 2.5
+  private_constant :RUBY_VERSION
+
   def assert_no_offenses(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    assert_predicate cop.offenses, :empty?, "Did not expect Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    assert_predicate(cop.offenses, :empty?, "Did not expect Rubocop to find offenses")
   end
 
   def assert_offense(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    refute_predicate cop.offenses, :empty?, "Expected Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    refute_predicate(cop.offenses, :empty?, "Expected Rubocop to find offenses")
   end
 
   def assert_no_autocorrect(source)
     corrected = autocorrect_source(source)
-    assert_equal source, corrected
+    assert_equal(source, corrected)
   end
 
   def autocorrect_source(source)
@@ -27,16 +31,15 @@ module RubocopHelper
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
     cop.instance_variable_get(:@options)[:auto_correct] = true
 
-    processed_source = RuboCop::ProcessedSource.new(source, 2.3, nil)
+    processed_source = RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil)
     investigate(processed_source)
 
-    corrector = RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector = RuboCop::Cop::Legacy::Corrector.new(processed_source.buffer, cop.corrections)
     corrector.rewrite
   end
 
   def investigate(processed_source)
     forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
-      next unless cop.join_force?(klass)
       instances << klass.new([cop])
     end
 

data/test/helpers_test.rb

@@ -17,10 +17,10 @@ class HelpersTest < Minitest::Test
     end
     StatsD.gauge('gauge', 15)
 
-    assert_equal 2, metrics.length
-    assert_equal 'counter', metrics[0].name
-    assert_equal 'gauge', metrics[1].name
-    assert_equal 12, metrics[1].value
+    assert_equal(2, metrics.length)
+    assert_equal('counter', metrics[0].name)
+    assert_equal('gauge', metrics[1].name)
+    assert_equal(12, metrics[1].value)
   end
 
   def test_capture_metrics_with_new_client
@@ -34,7 +34,7 @@ class HelpersTest < Minitest::Test
     end
     StatsD.gauge('gauge', 15)
 
-    assert_equal 2, metrics.length
+    assert_equal(2, metrics.length)
 
   ensure
     StatsD.singleton_client = @old_client

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}")
+    assert_equal("counter:1|c", @server.recvfrom(100).first)
   end
 end