statsd-instrument 2.9.2 → 3.0.0.pre1

data/test/deprecations_test.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DeprecationsTest < Minitest::Test
-  unless StatsD::Instrument.strict_mode_enabled?
-    class InstrumentedClass
-      extend StatsD::Instrument
-      def foo; end
-      statsd_count :foo, 'frequency', 0.5, ['tag'] # rubocop:disable StatsD/MetaprogrammingPositionalArguments
-      statsd_measure :foo, 'latency', as_dist: true # rubocop:disable StatsD/MeasureAsDistArgument
-      statsd_count_success :foo, 'frequency', prefix: 'foo' # rubocop:disable StatsD/MetricPrefixArgument
-    end
-  end
-
-  include StatsD::Instrument::Assertions
-
-  def setup
-    skip("Deprecation are not supported in strict mode") if StatsD::Instrument.strict_mode_enabled?
-  end
-
-  def test__deprecated__metaprogramming_method_with_positional_arguments
-    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
-    metric = metrics[0]
-    assert_equal :c, metric.type
-    assert_equal 'frequency', metric.name
-    assert_equal 1, metric.value
-    assert_equal 0.5, metric.sample_rate
-    assert_equal ["tag"], metric.tags
-  end
-
-  def test__deprecated__metaprogramming_statsd_measure_with_as_dist
-    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
-    metric = metrics[1]
-    assert_equal :d, metric.type
-    assert_equal 'latency', metric.name
-  end
-
-  def test__deprecated__metaprogramming_statsd_count_with_prefix
-    metrics = capture_statsd_calls { InstrumentedClass.new.foo }
-    metric = metrics[2]
-    assert_equal :c, metric.type
-    assert_equal 'foo.frequency.success', metric.name
-  end
-
-  # rubocop:disable StatsD/MetricValueKeywordArgument
-  def test__deprecated__statsd_measure_with_explicit_value_as_keyword_argument
-    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42) }
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
-    assert_equal :ms, metric.type
-  end
-
-  # rubocop:disable StatsD/MeasureAsDistArgument
-  def test__deprecated__statsd_measure_with_explicit_value_keyword_and_distribution_override
-    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42, as_dist: true) }
-    assert_equal 42, metric.value
-    assert_equal :d, metric.type
-  end
-  # rubocop:enable StatsD/MeasureAsDistArgument
-
-  def test__deprecated__statsd_increment_with_value_as_keyword_argument
-    metric = capture_statsd_call { StatsD.increment('values.foobar', value: 2) }
-    assert_equal StatsD.default_sample_rate, metric.sample_rate
-    assert_equal 2, metric.value
-  end
-
-  def test__deprecated__statsd_gauge_with_keyword_argument
-    metric = capture_statsd_call { StatsD.gauge('values.foobar', value: 13) }
-    assert_equal :g, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 13, metric.value
-  end
-  # rubocop:enable StatsD/MetricValueKeywordArgument
-
-  # rubocop:disable StatsD/MetricReturnValue
-  def test__deprecated__statsd_increment_returns_metric_instance
-    metric = StatsD.increment('key')
-    assert_kind_of StatsD::Instrument::Metric, metric
-    assert_equal 'key', metric.name
-    assert_equal :c, metric.type
-    assert_equal 1, metric.value
-  end
-  # rubocop:enable StatsD/MetricReturnValue
-
-  # rubocop:disable StatsD/PositionalArguments
-  def test__deprecated__statsd_increment_with_positional_argument_for_tags
-    metric = capture_statsd_call { StatsD.increment('values.foobar', 12, nil, ['test']) }
-    assert_equal StatsD.default_sample_rate, metric.sample_rate
-    assert_equal ['test'], metric.tags
-    assert_equal 12, metric.value
-    assert_equal StatsD.default_sample_rate, metric.sample_rate
-  end
-  # rubocop:enable StatsD/PositionalArguments
-
-  # rubocop:disable StatsD/MeasureAsDistArgument
-  def test__deprecated__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__deprecated__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__deprecated__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
-  # rubocop:enable StatsD/MeasureAsDistArgument
-
-  # rubocop:disable StatsD/MetricPrefixArgument
-  def test__deprecated__override_name_prefix
-    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
-  # rubocop:enable StatsD/MetricPrefixArgument
-
-  def test__deprecated__statsd_key_value
-    metric = capture_statsd_call { StatsD.key_value('values.foobar', 42) }
-    assert_equal :kv, metric.type
-    assert_equal 'values.foobar', metric.name
-    assert_equal 42, metric.value
-  end
-
-  protected
-
-  def capture_statsd_call(&block)
-    metrics = capture_statsd_calls(&block)
-    assert_equal 1, metrics.length
-    metrics.first
-  end
-end

data/test/logger_backend_test.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class LoggerBackendTest < Minitest::Test
-  def setup
-    logger = Logger.new(@io = StringIO.new)
-    logger.formatter = lambda { |_, _, _, msg| "#{msg}\n" }
-    @backend = StatsD::Instrument::Backends::LoggerBackend.new(logger)
-    @metric1 = StatsD::Instrument::Metric.new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd' })
-    @metric2 = StatsD::Instrument::Metric.new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
-  end
-
-  def test_logs_metrics
-    @backend.collect_metric(@metric1)
-    @backend.collect_metric(@metric2)
-    assert_equal <<~LOG, @io.string
-      [StatsD] mock.counter:1|c|#a:b,c:d
-      [StatsD] mock.measure:123|ms|@0.3
-    LOG
-  end
-end

data/test/metric_test.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class MetricTest < Minitest::Test
-  def test_required_arguments
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :c) }
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(name: 'test') }
-    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :ms, name: 'test') }
-  end
-
-  def test_default_values
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
-    assert_equal 1, m.value
-    assert_equal StatsD.default_sample_rate, m.sample_rate
-    assert m.tags.nil?
-  end
-
-  def test_bad_metric_name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric')
-    assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric')
-    assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric')
-    assert_equal 'my_metric', m.name
-  end
-
-  def test_handle_bad_tags
-    assert_equal ['ignored'], StatsD::Instrument::Metric.normalize_tags(['igno|red'])
-    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags("lol::class" => "omg::lol")
-  end
-
-  def test_rewrite_tags_provided_as_hash
-    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(tag: 'value')
-    assert_equal ['tag1:v1', 'tag2:v2'], StatsD::Instrument::Metric.normalize_tags(tag1: 'v1', tag2: 'v2')
-  end
-
-  def test_default_tags
-    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.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
-end

data/test/udp_backend_test.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class UDPBackendTest < Minitest::Test
-  def setup
-    StatsD.legacy_singleton_client.stubs(:backend).returns(@backend = StatsD::Instrument::Backends::UDPBackend.new)
-    @backend.stubs(:rand).returns(0.0)
-
-    UDPSocket.stubs(:new).returns(@socket = mock('socket'))
-    @socket.stubs(:connect)
-    @socket.stubs(:send).returns(1)
-
-    StatsD.stubs(:logger).returns(@logger = mock('logger'))
-  end
-
-  def test_changing_host_or_port_should_create_new_socket
-    @socket.expects(:connect).with('localhost', 1234).once
-    @socket.expects(:connect).with('localhost', 2345).once
-    @socket.expects(:connect).with('127.0.0.1', 2345).once
-
-    @backend.server = "localhost:1234"
-    @backend.socket
-
-    @backend.port = 2345
-    @backend.socket
-
-    @backend.host = '127.0.0.1'
-    @backend.socket
-  end
-
-  def test_collect_respects_sampling_rate
-    @socket.expects(:send).once.returns(1)
-    metric = StatsD::Instrument::Metric.new(type: :c, name: 'test', sample_rate: 0.5)
-
-    @backend.stubs(:rand).returns(0.4)
-    @backend.collect_metric(metric)
-
-    @backend.stubs(:rand).returns(0.6)
-    @backend.collect_metric(metric)
-  end
-
-  def test_support_counter_syntax
-    @backend.expects(:write_packet).with('counter:1|c').once
-    StatsD.increment('counter', sample_rate: 1.0)
-
-    @backend.expects(:write_packet).with('counter:1|c|@0.5').once
-    StatsD.increment('counter', sample_rate: 0.5)
-  end
-
-  def test_supports_gauge_syntax
-    @backend.expects(:write_packet).with('fooy:1.23|g')
-    StatsD.gauge('fooy', 1.23)
-
-    @backend.expects(:write_packet).with('fooy:42|g|@0.01')
-    StatsD.gauge('fooy', 42, sample_rate: 0.01)
-  end
-
-  def test_supports_set_syntax
-    @backend.expects(:write_packet).with('unique:10.0.0.10|s')
-    StatsD.set('unique', '10.0.0.10')
-
-    @backend.expects(:write_packet).with('unique:10.0.0.10|s|@0.01')
-    StatsD.set('unique', '10.0.0.10', sample_rate: 0.01)
-  end
-
-  def test_support_measure_syntax
-    @backend.expects(:write_packet).with('duration:1.23|ms')
-    StatsD.measure('duration', 1.23)
-
-    @backend.expects(:write_packet).with('duration:0.42|ms|@0.01')
-    StatsD.measure('duration', 0.42, sample_rate: 0.01)
-  end
-
-  def test_histogram_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('fooh:42.4|h')
-    StatsD.histogram('fooh', 42.4)
-  end
-
-  def test_distribution_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('fooh:42.4|d')
-    StatsD.distribution('fooh', 42.4)
-  end
-
-  def test_event_on_datadog
-    @backend.implementation = :datadog
-    @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
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with("_e{8,5}:fooh\\n\\n|baz\\n")
-    StatsD.event("fooh\n\n", "baz\n")
-  end
-
-  def test_event_on_datadog_ignores_invalid_metadata
-    @backend.implementation = :datadog
-    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
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.event('fooh', 'bar')
-  end
-
-  def test_service_check_on_datadog
-    @backend.implementation = :datadog
-    @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
-    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
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.service_check('fooh', 'bar')
-  end
-
-  def test_histogram_warns_if_not_using_datadog
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.histogram('fooh', 42.4)
-  end
-
-  def test_distribution_warns_if_not_using_datadog
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.distribution('fooh', 42.4)
-  end
-
-  def test_supports_key_value_syntax_on_statsite
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @backend.implementation = :statsite
-    @backend.expects(:write_packet).with("fooy:42|kv\n")
-    StatsD.key_value('fooy', 42)
-  end
-
-  # For key_value metrics (only supported by statsite), the sample rate
-  # part of the datagram format is (ab)used to be set to a timestamp instead.
-  # Changing that to `sample_rate: timestamp` does not make sense, so we
-  # disable the rubocop rule for positional arguments for now,
-  # until we figure out how we want to handle this.
-
-  # rubocop:disable StatsD/PositionalArguments
-  def test_supports_key_value_with_timestamp_on_statsite
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @backend.implementation = :statsite
-    @backend.expects(:write_packet).with("fooy:42|kv|@123456\n")
-    StatsD.key_value('fooy', 42, 123456)
-  end
-  # rubocop:enable StatsD/PositionalArguments
-
-  def test_warn_when_using_key_value_and_not_on_statsite
-    skip if StatsD::Instrument.strict_mode_enabled?
-    @backend.implementation = :other
-    @backend.expects(:write_packet).never
-    @logger.expects(:warn)
-    StatsD.key_value('fookv', 3.33)
-  end
-
-  def test_support_tags_syntax_on_datadog
-    @backend.implementation = :datadog
-    @backend.expects(:write_packet).with("fooc:3|c|#topic:foo,bar")
-    StatsD.increment('fooc', 3, tags: ['topic:foo', 'bar'])
-  end
-
-  def test_socket_error_should_not_raise_but_log
-    @socket.stubs(:connect).raises(SocketError)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_system_call_error_should_not_raise_but_log
-    @socket.stubs(:send).raises(Errno::ETIMEDOUT)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_io_error_should_not_raise_but_log
-    @socket.stubs(:send).raises(IOError)
-    @logger.expects(:error)
-    StatsD.increment('fail')
-  end
-
-  def test_socket_error_should_invalidate_socket
-    seq = sequence('fail_then_succeed')
-
-    @socket.expects(:connect).with('localhost', 8125)
-    @socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
-
-    @socket.expects(:send).returns(1).in_sequence(seq)
-    @logger.expects(:error)
-
-    StatsD.increment('fail')
-    StatsD.increment('succeed')
-  end
-end