statsd-instrument 3.0.1 → 3.1.2

data/test/datagram_test.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+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'
+    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')
+    assert_includes(parsed.tags, "code_source:NilController#NilAction")
   end
 end

data/test/dogstatsd_datagram_builder_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class DogStatsDDatagramBuilderTest < Minitest::Test
   def setup
@@ -8,56 +8,56 @@ class DogStatsDDatagramBuilderTest < Minitest::Test
   end
 
   def test_raises_on_unsupported_metrics
-    assert_raises(NotImplementedError) { @datagram_builder.kv('foo', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.kv("foo", 10, nil, nil) }
   end
 
   def test_simple_service_check
-    datagram = @datagram_builder._sc('service', :ok)
-    assert_equal('_sc|service|0', datagram)
+    datagram = @datagram_builder._sc("service", :ok)
+    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("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')
+    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)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
     assert_equal(:_sc, parsed_datagram.type)
-    assert_equal('service', parsed_datagram.name)
+    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("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("blah", parsed_datagram.message)
   end
 
   def test_simple_event
-    datagram = @datagram_builder._e('hello', "world")
-    assert_equal('_e{5,5}:hello|world', datagram)
+    datagram = @datagram_builder._e("hello", "world")
+    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("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' })
+    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)
+      "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("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("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)

data/test/environment_test.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 module Rails; end
 
 class EnvironmentTest < Minitest::Test
   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',
+      "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',
+      "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)
+    Rails.stubs(:env).returns("production")
+    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_client_returns_client_instance
@@ -37,22 +37,31 @@ class EnvironmentTest < Minitest::Test
   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')
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "development")
     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')
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "test")
     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)
+  def test_client_from_env_uses_batched_udp_sink_in_staging_environment
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "staging")
+    assert_kind_of(StatsD::Instrument::BatchedUDPSink, env.client.sink)
+  end
+
+  def test_client_from_env_uses_batched_udp_sink_in_production_environment
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "production")
+    assert_kind_of(StatsD::Instrument::BatchedUDPSink, 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')
+  def test_client_from_env_uses_regular_udp_sink_when_flush_interval_is_0
+    env = StatsD::Instrument::Environment.new(
+      "STATSD_USE_NEW_CLIENT" => "1",
+      "STATSD_ENV" => "staging",
+      "STATSD_FLUSH_INTERVAL" => "0.0",
+    )
     assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 end

data/test/helpers/rubocop_helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
+require "rubocop/cop/legacy/corrector"
 
 module RubocopHelper
   attr_accessor :cop
@@ -33,13 +34,12 @@ module RubocopHelper
     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

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class HelpersTest < Minitest::Test
   def setup
     test_class = Class.new(Minitest::Test)
     test_class.send(:include, StatsD::Instrument::Helpers)
-    @test_case = test_class.new('fake')
+    @test_case = test_class.new("fake")
   end
 
   def test_capture_metrics_inside_block_only
-    StatsD.increment('counter')
+    StatsD.increment("counter")
     metrics = @test_case.capture_statsd_calls do
-      StatsD.increment('counter')
-      StatsD.gauge('gauge', 12)
+      StatsD.increment("counter")
+      StatsD.gauge("gauge", 12)
     end
-    StatsD.gauge('gauge', 15)
+    StatsD.gauge("gauge", 15)
 
     assert_equal(2, metrics.length)
-    assert_equal('counter', metrics[0].name)
-    assert_equal('gauge', metrics[1].name)
+    assert_equal("counter", metrics[0].name)
+    assert_equal("gauge", metrics[1].name)
     assert_equal(12, metrics[1].value)
   end
 
@@ -27,12 +27,12 @@ class HelpersTest < Minitest::Test
     @old_client = StatsD.singleton_client
     StatsD.singleton_client = StatsD::Instrument::Client.new
 
-    StatsD.increment('counter')
+    StatsD.increment("counter")
     metrics = @test_case.capture_statsd_datagrams do
-      StatsD.increment('counter')
-      StatsD.gauge('gauge', 12)
+      StatsD.increment("counter")
+      StatsD.gauge("gauge", 12)
     end
-    StatsD.gauge('gauge', 15)
+    StatsD.gauge("gauge", 15)
 
     assert_equal(2, metrics.length)
 

data/test/integration_test.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class IntegrationTest < Minitest::Test
   def setup
     @server = UDPSocket.new
-    @server.bind('localhost', 0)
+    @server.bind("localhost", 0)
 
     @env = StatsD::Instrument::Environment.new(
-      'STATSD_ADDR' => "#{@server.addr[2]}:#{@server.addr[1]}",
-      'STATSD_IMPLEMENTATION' => 'dogstatsd',
-      'STATSD_ENV' => 'production',
+      "STATSD_ADDR" => "#{@server.addr[2]}:#{@server.addr[1]}",
+      "STATSD_IMPLEMENTATION" => "dogstatsd",
+      "STATSD_ENV" => "production",
     )
 
     @old_client = StatsD.singleton_client
@@ -23,7 +23,7 @@ class IntegrationTest < Minitest::Test
   end
 
   def test_live_local_udp_socket
-    StatsD.increment('counter')
+    StatsD.increment("counter")
     assert_equal("counter:1|c", @server.recvfrom(100).first)
   end
 end

data/test/log_sink_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class LogSinkTest < Minitest::Test
   def test_log_sink
@@ -10,7 +10,7 @@ class LogSinkTest < Minitest::Test
     end
 
     log_sink = StatsD::Instrument::LogSink.new(logger)
-    log_sink << 'foo:1|c' << 'bar:1|c'
+    log_sink << "foo:1|c" << "bar:1|c"
 
     assert_equal(<<~LOG, log.string)
       DEBUG: [StatsD] foo:1|c

data/test/matchers_test.rb

@@ -1,116 +1,116 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/matchers'
+require "test_helper"
+require "statsd/instrument/matchers"
 
 class MatchersTest < Minitest::Test
   def test_statsd_increment_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('counter') }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", {})
+      .matches?(lambda { StatsD.increment("counter") }))
   end
 
   def test_statsd_increment_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('not_counter') }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", {})
+      .matches?(lambda { StatsD.increment("not_counter") }))
   end
 
   def test_statsd_increment_compound_matched
-    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
-    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
+    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["a"])
+    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["b"])
 
     assert(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
-      StatsD.increment('counter', tags: ['a'])
-      StatsD.increment('counter', tags: ['b'])
+      StatsD.increment("counter", tags: ["a"])
+      StatsD.increment("counter", tags: ["b"])
     }))
   end
 
   def test_statsd_increment_compound_not_matched
-    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
-    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
+    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["a"])
+    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["b"])
 
     refute(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
-      StatsD.increment('counter', tags: ['a'])
-      StatsD.increment('counter', tags: ['a'])
+      StatsD.increment("counter", tags: ["a"])
+      StatsD.increment("counter", tags: ["a"])
     }))
   end
 
   def test_statsd_increment_with_times_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
-      .matches?(lambda { StatsD.increment('counter') }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", times: 1)
+      .matches?(lambda { StatsD.increment("counter") }))
   end
 
   def test_statsd_increment_with_times_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
-      .matches?(lambda { 3.times { StatsD.increment('counter') } }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", times: 2)
+      .matches?(lambda { 3.times { StatsD.increment("counter") } }))
   end
 
   def test_statsd_increment_with_sample_rate_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment("counter", sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment("counter", sample_rate: 0.7) }))
   end
 
   def test_statsd_increment_with_value_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
-      .matches?(lambda { StatsD.increment('counter') }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", value: 1)
+      .matches?(lambda { StatsD.increment("counter") }))
   end
 
   def test_statsd_increment_with_value_matched_when_multiple_metrics
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
-      StatsD.increment('counter', 2)
-      StatsD.increment('counter', 1)
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", value: 1).matches?(lambda {
+      StatsD.increment("counter", 2)
+      StatsD.increment("counter", 1)
     }))
   end
 
   def test_statsd_increment_with_value_not_matched_when_multiple_metrics
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
-      StatsD.increment('counter', 2)
-      StatsD.increment('counter', 3)
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", value: 1).matches?(lambda {
+      StatsD.increment("counter", 2)
+      StatsD.increment("counter", 3)
     }))
   end
 
   def test_statsd_increment_with_value_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
-      .matches?(lambda { StatsD.increment('counter') }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", value: 3)
+      .matches?(lambda { StatsD.increment("counter") }))
   end
 
   def test_statsd_increment_with_tags_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["a", "b"])
+      .matches?(lambda { StatsD.increment("counter", tags: ["a", "b"]) }))
   end
 
   def test_statsd_increment_with_tags_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['c']) }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["a", "b"])
+      .matches?(lambda { StatsD.increment("counter", tags: ["c"]) }))
   end
 
   def test_statsd_increment_with_times_and_value_matched
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
-      StatsD.increment('counter', 1)
-      StatsD.increment('counter', 1)
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", times: 2, value: 1).matches?(lambda {
+      StatsD.increment("counter", 1)
+      StatsD.increment("counter", 1)
     }))
   end
 
   def test_statsd_increment_with_times_and_value_not_matched
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
-      StatsD.increment('counter', 1)
-      StatsD.increment('counter', 2)
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", times: 2, value: 1).matches?(lambda {
+      StatsD.increment("counter", 1)
+      StatsD.increment("counter", 2)
     }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment("counter", sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_not_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment("counter", sample_rate: 0.7) }))
   end
 end