statsd-instrument 2.5.1 → 2.6.0

data/test/environment_test.rb

@@ -10,22 +10,22 @@ class EnvironmentTest < Minitest::Test
     ENV['IMPLEMENTATION'] = nil
   end
 
-  def test_uses_logger_in_development_environment
+  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_uses_null_backend_in_test_environment
+  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_uses_udp_backend_in_production_environment
+  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_uses_environment_variables_in_production_environment
+  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'
@@ -36,12 +36,78 @@ class EnvironmentTest < Minitest::Test
     assert_equal :datadog, backend.implementation
   end
 
-  def test_uses_env_when_rails_does_not_respond_to_env
-    assert_equal ENV['ENV'], StatsD::Instrument::Environment.environment
+  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
   end
 
-  def test_uses_rails_env_when_rails_is_available
+  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
+  end
+
+  def test_environment_uses_rails_env_when_rails_is_available
     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
+  end
+
+  def test_default_client_uses_log_sink_in_development_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'development')
+    assert_kind_of StatsD::Instrument::LogSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_null_sink_in_test_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'test')
+    assert_kind_of StatsD::Instrument::NullSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_udp_sink_in_staging_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'staging')
+    assert_kind_of StatsD::Instrument::UDPSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_udp_sink_in_production_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'production')
+    assert_kind_of StatsD::Instrument::UDPSink, env.default_client.sink
+  end
+
+  def test_default_client_respects_statsd_environment_variables
+    env = StatsD::Instrument::Environment.new(
+      'STATSD_ENV' => 'production',
+      'STATSD_IMPLEMENTATION' => 'datadog',
+      'STATSD_ADDR' => 'foo:8125',
+      'STATSD_SAMPLE_RATE' => "0.1",
+      'STATSD_PREFIX' => "foo",
+      'STATSD_DEFAULT_TAGS' => "foo,bar:baz",
+    )
+
+    assert_equal StatsD::Instrument::DogStatsDDatagramBuilder, env.default_client.datagram_builder_class
+    assert_equal 'foo', env.default_client.sink.host
+    assert_equal 8125, env.default_client.sink.port
+    assert_equal 0.1, env.default_client.default_sample_rate
+    assert_equal "foo", env.default_client.prefix
+    assert_equal ["foo", "bar:baz"], env.default_client.default_tags
+  end
+
+  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 'localhost', env.default_client.sink.host
+    assert_equal 8125, env.default_client.sink.port
+    assert_equal 1.0, env.default_client.default_sample_rate
+    assert_nil env.default_client.prefix
+    assert_nil env.default_client.default_tags
+  end
 end

data/test/log_sink_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class LogSinktest < Minitest::Test
+  def test_log_sink
+    logger = Logger.new(log = StringIO.new)
+    logger.formatter = proc do |severity, _datetime, _progname, msg|
+      "#{severity}: #{msg}\n"
+    end
+
+    log_sink = StatsD::Instrument::LogSink.new(logger)
+    log_sink << 'foo:1|c' << 'bar:1|c'
+
+    assert_equal <<~LOG, log.string
+      DEBUG: [StatsD] foo:1|c
+      DEBUG: [StatsD] bar:1|c
+    LOG
+  end
+
+  def test_log_sink_chomps_trailing_newlines
+    logger = Logger.new(log = StringIO.new)
+    logger.formatter = proc do |severity, _datetime, _progname, msg|
+      "#{severity}: #{msg}\n"
+    end
+
+    log_sink = StatsD::Instrument::LogSink.new(logger)
+    log_sink << "foo:1|c\n" << "bar:1|c\n"
+
+    assert_equal <<~LOG, log.string
+      DEBUG: [StatsD] foo:1|c
+      DEBUG: [StatsD] bar:1|c
+    LOG
+  end
+end

data/test/null_sink_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class NullSinktest < Minitest::Test
+  def test_null_sink
+    null_sink = StatsD::Instrument::NullSink.new
+    null_sink << 'foo:1|c' << 'bar:1|c'
+    pass # We don't have anything to assert, except that no exception was raised
+  end
+end

data/test/rubocop/measure_as_dist_argument_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MeasureAsDistArgumentTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MeasureAsDistArgument.new
+    end
+
+    def test_ok_for_metric_method_without_as_dist_argument
+      assert_no_offenses("StatsD.measure('foo', 123)")
+      assert_no_offenses("StatsD.measure('foo', 123, sample_rate: 3)")
+      assert_no_offenses("StatsD.measure('foo') {}")
+    end
+
+    def test_ok_for_other_metric_methods
+      assert_no_offenses("StatsD.increment('foo', as_dist: true)")
+    end
+
+    def test_ok_for_metaprogramming_method_without_as_dist_argument
+      assert_no_offenses("statsd_measure(:method, 'metric_name', sample_rate: 1) {}")
+    end
+
+    def test_ok_for_other_metaprogramming_methods
+      assert_no_offenses("statsd_distribution(:method, 'metric_name', as_dist: true) {}")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metric_method
+      assert_offense("StatsD.measure('foo', 123, sample_rate: 1, as_dist: true, tags: ['foo'])")
+      assert_offense("StatsD.measure('foo', 123, as_dist: false)")
+      assert_offense("StatsD.measure('foo', as_dist: true, &block)")
+      assert_offense("StatsD.measure('foo', as_dist: true) { } ")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metaprogramming_method
+      assert_offense("statsd_measure(:method, 'foo', as_dist: true, &block)")
+      assert_offense("statsd_measure(:method, 'foo', as_dist: false) { } ")
+    end
+  end
+end

data/test/rubocop/metaprogramming_positional_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/rubocop/metaprogramming_positional_arguments'
+require 'statsd/instrument/rubocop'
 
 module Rubocop
   class MetaprogrammingPositionalArgumentsTest < Minitest::Test

data/test/rubocop/metric_prefix_argument_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MetricPrefixArgumentTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MetricPrefixArgument.new
+    end
+
+    def test_ok_for_metric_method_without_prefix_argument
+      assert_no_offenses("StatsD.measure('foo', 123) {}")
+      assert_no_offenses("StatsD.increment('foo', 123, sample_rate: 3, no_prefix: true)")
+      assert_no_offenses("StatsD.gauge('foo', 123)")
+    end
+
+    def test_ok_for_metaprogramming_method_without_prefix_argument
+      assert_no_offenses("statsd_measure(:method, 'metric_name')")
+      assert_no_offenses("statsd_count(:method, 'metric_name', sample_rate: 1, no_pefix: true)")
+      assert_no_offenses("statsd_count_if(:method, 'metric_name', sample_rate: 1) {}")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metric_method
+      assert_offense("StatsD.measure('foo', 123, sample_rate: 1, prefix: 'pre', tags: ['bar'])")
+      assert_offense("StatsD.gauge('foo', 123, prefix: nil)")
+      assert_offense("StatsD.increment('foo', prefix: 'pre', &block)")
+      assert_offense("StatsD.set('foo', prefix: 'pre') { } ")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metaprogramming_method
+      assert_offense("statsd_measure(:method, 'foo', prefix: 'foo')")
+      assert_offense("statsd_count_if(:method, 'foo', prefix: nil) { } ")
+    end
+  end
+end

data/test/rubocop/metric_return_value_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/rubocop/metric_return_value'
+require 'statsd/instrument/rubocop'
 
 module Rubocop
   class MetricReturnValueTest < Minitest::Test

data/test/rubocop/metric_value_keyword_argument_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/rubocop/metric_value_keyword_argument'
+require 'statsd/instrument/rubocop'
 
 module Rubocop
   class MetricValueKeywordArgumentTest < Minitest::Test

data/test/rubocop/positional_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/rubocop/positional_arguments'
+require 'statsd/instrument/rubocop'
 
 module Rubocop
   class PositionalArgumentsTest < Minitest::Test

data/test/rubocop/splat_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'statsd/instrument/rubocop/splat_arguments'
+require 'statsd/instrument/rubocop'
 
 module Rubocop
   class SplatArgumentsTest < Minitest::Test

data/test/statsd_datagram_builder_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class StatsDDatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::StatsDDatagramBuilder.new
+  end
+
+  def test_raises_on_unsupported_metrics
+    assert_raises(NotImplementedError) { @datagram_builder.h('fo:o', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.d('fo:o', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.kv('fo:o', 10, nil, nil) }
+  end
+
+  def test_raises_when_using_tags
+    assert_raises(NotImplementedError) { @datagram_builder.c('fo:o', 10, nil, foo: 'bar') }
+    assert_raises(NotImplementedError) { StatsD::Instrument::StatsDDatagramBuilder.new(default_tags: ['foo']) }
+  end
+end

data/test/statsd_instrumentation_test.rb

@@ -248,16 +248,6 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
 
-  def test_statsd_measure_as_distribution
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', as_dist: true
-
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
   def test_statsd_distribution
     ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
 
@@ -351,20 +341,6 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end
 
-  def test_statsd_macro_can_overwrite_prefix
-    StatsD.prefix = 'Foo'
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_measure :sync, 'ActiveMerchant.Gateway.sync', prefix: 'Bar'
-    StatsD.prefix = 'Quc'
-
-    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, statsd_calls.length
-    assert_equal "Bar.ActiveMerchant.Gateway.sync", statsd_calls.first.name
-  ensure
-    StatsD.prefix = nil
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_measure :sync, 'ActiveMerchant.Gateway.sync'
-  end
-
   def test_statsd_macro_can_disable_prefix
     StatsD.prefix = 'Foo'
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument

data/test/statsd_test.rb

@@ -21,11 +21,6 @@ class StatsDTest < Minitest::Test
     assert_equal :ms, metric.type
   end
 
-  def test_statsd_measure_with_explicit_value_and_distribution_override
-    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, as_dist: true) }
-    assert_equal :d, metric.type
-  end
-
   def test_statsd_measure_without_value_or_block
     assert_raises(ArgumentError) { StatsD.measure('values.foobar', tags: 123) }
   end
@@ -43,23 +38,11 @@ class StatsDTest < Minitest::Test
     assert_equal 1120.0, metric.value
   end
 
-  def test_statsd_measure_use_distribution_override_for_a_block
-    metric = capture_statsd_call do
-      StatsD.measure('values.foobar', as_dist: true) { 'foo' }
-    end
-    assert_equal :d, metric.type
-  end
-
   def test_statsd_measure_returns_return_value_of_block
     return_value = StatsD.measure('values.foobar') { 'sarah' }
     assert_equal 'sarah', return_value
   end
 
-  def test_statsd_measure_as_distribution_returns_return_value_of_block_even_if_nil
-    return_value = StatsD.measure('values.foobar', as_dist: true) { nil }
-    assert_nil return_value
-  end
-
   def test_statsd_measure_with_return_in_block_still_captures
     Process.stubs(:clock_gettime).returns(5.0, 6.12)
     result = nil
@@ -236,12 +219,6 @@ class StatsDTest < Minitest::Test
 
     m = capture_statsd_call { StatsD.increment('counter', no_prefix: true) }
     assert_equal 'counter', m.name
-
-    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar") }
-    assert_equal 'foobar.counter', m.name
-
-    m = capture_statsd_call { StatsD.increment('counter', prefix: "foobar", no_prefix: true) }
-    assert_equal 'counter', m.name
   end
 
   protected

data/test/test_helper.rb

@@ -11,8 +11,6 @@ require 'statsd-instrument'
 
 require_relative 'helpers/rubocop_helper'
 
-require 'statsd/instrument/strict' if ENV['STATSD_STRICT_MODE']
-
 module StatsD::Instrument
   def self.strict_mode_enabled?
     StatsD::Instrument.const_defined?(:Strict) &&

data/test/udp_backend_test.rb

@@ -86,8 +86,8 @@ class UDPBackendTest < Minitest::Test
 
   def test_event_on_datadog
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz|h:localhost:3000|@0.01|#foo')
-    StatsD.event('fooh', 'baz', hostname: 'localhost:3000', sample_rate: 0.01, tags: ["foo"])
+    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz|h:localhost|#foo')
+    StatsD.event('fooh', 'baz', hostname: 'localhost', tags: ["foo"])
   end
 
   def test_event_on_datadog_escapes_newlines
@@ -98,8 +98,13 @@ class UDPBackendTest < Minitest::Test
 
   def test_event_on_datadog_ignores_invalid_metadata
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{4,3}:fooh|baz')
-    StatsD.event('fooh', 'baz', i_am_not_supported: 'not-supported')
+    if StatsD::Instrument.strict_mode_enabled?
+      assert_raises(ArgumentError) { StatsD.event('fooh', 'baz', sample_rate: 0.01) }
+      assert_raises(ArgumentError) { StatsD.event('fooh', 'baz', unsupported: 'foo') }
+    else
+      @backend.expects(:write_packet).with('_e{4,3}:fooh|baz')
+      StatsD.event('fooh', 'baz', sample_rate: 0.01, i_am_not_supported: 'not-supported')
+    end
   end
 
   def test_event_warns_when_not_using_datadog
@@ -111,14 +116,26 @@ class UDPBackendTest < Minitest::Test
 
   def test_service_check_on_datadog
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_sc|fooh|baz|h:localhost:3000|@0.01|#foo')
-    StatsD.service_check('fooh', 'baz', hostname: 'localhost:3000', sample_rate: 0.01, tags: ["foo"])
+    @backend.expects(:write_packet).with('_sc|fooh|0|h:localhost|#foo')
+    StatsD.service_check('fooh', 0, hostname: 'localhost', tags: ["foo"])
   end
 
   def test_service_check_on_datadog_ignores_invalid_metadata
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_sc|fooh|baz')
-    StatsD.service_check('fooh', 'baz', i_am_not_supported: 'not-supported')
+    if StatsD::Instrument.strict_mode_enabled?
+      assert_raises(ArgumentError) { StatsD.service_check('fooh', "warning", sample_rate: 0.01) }
+      assert_raises(ArgumentError) { StatsD.service_check('fooh', "warning", unsupported: 'foo') }
+    else
+      @backend.expects(:write_packet).with('_sc|fooh|1')
+      StatsD.service_check('fooh', "warning", sample_rate: 0.01, i_am_not_supported: 'not-supported')
+    end
+  end
+
+  def test_service_check_on_datadog_will_append_message_as_final_metadata_field
+    @backend.implementation = :datadog
+    @backend.expects(:write_packet).with('_sc|fooh|0|d:1230768000|#quc|m:Everything OK')
+    StatsD.service_check('fooh', :ok, message: "Everything OK",
+      timestamp: Time.parse('2009-01-01T00:00:00Z'), tags: ['quc'])
   end
 
   def test_service_check_warns_when_not_using_datadog

data/test/udp_sink_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class UDPSinktest < Minitest::Test
+  def setup
+    @receiver = UDPSocket.new
+    @receiver.bind('localhost', 0)
+    @host = @receiver.addr[2]
+    @port = @receiver.addr[1]
+  end
+
+  def teardown
+    @receiver.close
+  end
+
+  def test_udp_sink_sends_data_over_udp
+    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    udp_sink << 'foo:1|c'
+
+    datagram, _source = @receiver.recvfrom(100)
+    assert_equal 'foo:1|c', datagram
+  end
+
+  def test_sample?
+    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    assert udp_sink.sample?(1)
+    refute udp_sink.sample?(0)
+
+    udp_sink.stubs(:rand).returns(0.3)
+    assert udp_sink.sample?(0.5)
+
+    udp_sink.stubs(:rand).returns(0.7)
+    refute udp_sink.sample?(0.5)
+  end
+
+  def test_parallelism
+    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    50.times { |i| Thread.new { udp_sink << "foo:#{i}|c" << "bar:#{i}|c" } }
+    datagrams = []
+    100.times do
+      datagram, _source = @receiver.recvfrom(100)
+      datagrams << datagram
+    end
+
+    assert_equal 100, datagrams.size
+  end
+
+  def test_socket_error_should_invalidate_socket
+    UDPSocket.stubs(:new).returns(socket = mock('socket'))
+
+    seq = sequence('connect_fail_connect_succeed')
+    socket.expects(:connect).with('localhost', 8125).in_sequence(seq)
+    socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
+    socket.expects(:connect).with('localhost', 8125).in_sequence(seq)
+    socket.expects(:send).returns(1).in_sequence(seq)
+
+    udp_sink = StatsD::Instrument::UDPSink.new('localhost', 8125)
+    udp_sink << 'foo:1|c'
+    udp_sink << 'bar:1|c'
+  end
+
+  def test_sends_datagram_in_signal_handler
+    udp_sink = StatsD::Instrument::UDPSink.new(@host, @port)
+    pid = fork do
+      Signal.trap('TERM') do
+        udp_sink << "exiting:1|c"
+        Process.exit!(0)
+      end
+
+      sleep(10)
+    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", @receiver.recvfrom_nonblock(100).first
+
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
+  end
+end