statsd-instrument 3.0.0 → 3.0.1

data/statsd-instrument.gemspec

@@ -16,15 +16,9 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
 
   spec.files = `git ls-files`.split($/)
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'minitest'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'mocha'
-  spec.add_development_dependency 'yard'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'benchmark-ips'
+  spec.metadata['allowed_push_host'] = "https://rubygems.org"
 end

data/test/assertions_test.rb

@@ -31,7 +31,7 @@ class AssertionsTest < Minitest::Test
         StatsD.increment('counter')
       end
     end
-    assert_equal assertion.message, "No StatsD calls for metric counter expected."
+    assert_equal(assertion.message, "No StatsD calls for metric counter expected.")
 
     @test_case.assert_no_statsd_calls('counter1', 'counter2') do
       # noop
@@ -49,21 +49,21 @@ class AssertionsTest < Minitest::Test
         StatsD.increment('counter3')
       end
     end
-    assert_equal assertion.message, "No StatsD calls for metric counter1, counter2 expected."
+    assert_equal(assertion.message, "No StatsD calls for metric counter1, counter2 expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_no_statsd_calls('counter0', 'counter1', 'counter2') do
         StatsD.increment('counter1')
       end
     end
-    assert_equal assertion.message, "No StatsD calls for metric counter1 expected."
+    assert_equal(assertion.message, "No StatsD calls for metric counter1 expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_no_statsd_calls do
         StatsD.increment('other')
       end
     end
-    assert_equal assertion.message, "No StatsD calls for metric other expected."
+    assert_equal(assertion.message, "No StatsD calls for metric other expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_no_statsd_calls do
@@ -71,7 +71,7 @@ class AssertionsTest < Minitest::Test
         StatsD.increment('another')
       end
     end
-    assert_equal assertion.message, "No StatsD calls for metric other, another expected."
+    assert_equal(assertion.message, "No StatsD calls for metric other, another expected.")
   end
 
   def test_assert_statsd
@@ -202,8 +202,8 @@ class AssertionsTest < Minitest::Test
       end
     end
 
-    assert_includes assertion.message, "Captured metrics with the same key"
-    assert_includes assertion.message, "MyJob"
+    assert_includes(assertion.message, "Captured metrics with the same key")
+    assert_includes(assertion.message, "MyJob")
   end
 
   def test_capture_and_assert
@@ -367,7 +367,7 @@ class AssertionsTest < Minitest::Test
         end
       end
     end
-    assert_includes assertion.message, "No StatsD calls for metric counter of type c were made"
+    assert_includes(assertion.message, "No StatsD calls for metric counter of type c were made")
   end
 
   def test_assertion_block_with_unexpected_exceptions
@@ -377,7 +377,7 @@ class AssertionsTest < Minitest::Test
         raise "unexpected"
       end
     end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_raises(RuntimeError) do
@@ -387,7 +387,7 @@ class AssertionsTest < Minitest::Test
         end
       end
     end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_raises(RuntimeError) do
@@ -396,7 +396,7 @@ class AssertionsTest < Minitest::Test
         end
       end
     end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
   end
 
   def test_assertion_block_with_other_assertion_failures
@@ -406,6 +406,6 @@ class AssertionsTest < Minitest::Test
         @test_case.flunk('other assertion failure')
       end
     end
-    assert_equal "other assertion failure", assertion.message
+    assert_equal("other assertion failure", assertion.message)
   end
 end

data/test/capture_sink_test.rb

@@ -7,9 +7,9 @@ class CaptureSinkTest < Minitest::Test
     capture_sink = StatsD::Instrument::CaptureSink.new(parent: [])
     capture_sink << 'foo:1|c'
 
-    assert_equal 1, capture_sink.datagrams.length
-    assert_kind_of StatsD::Instrument::Datagram, capture_sink.datagrams.first
-    assert_equal 'foo:1|c', capture_sink.datagrams.first.source
+    assert_equal(1, capture_sink.datagrams.length)
+    assert_kind_of(StatsD::Instrument::Datagram, capture_sink.datagrams.first)
+    assert_equal('foo:1|c', capture_sink.datagrams.first.source)
   end
 
   def test_capture_sink_sends_datagrams_to_parent
@@ -17,7 +17,7 @@ class CaptureSinkTest < Minitest::Test
     capture_sink = StatsD::Instrument::CaptureSink.new(parent: parent)
     capture_sink << 'foo:1|c' << 'bar:1|c'
 
-    assert_equal ['foo:1|c', 'bar:1|c'], parent
+    assert_equal(['foo:1|c', 'bar:1|c'], parent)
   end
 
   def test_nesting_capture_sink_instances
@@ -28,15 +28,15 @@ class CaptureSinkTest < Minitest::Test
     outer_capture_sink << 'foo:1|c'
     inner_capture_sink << 'bar:1|c'
 
-    assert_equal ['foo:1|c', 'bar:1|c'], outer_capture_sink.datagrams.map(&:source)
-    assert_equal ['bar:1|c'], inner_capture_sink.datagrams.map(&:source)
+    assert_equal(['foo:1|c', 'bar:1|c'], outer_capture_sink.datagrams.map(&:source))
+    assert_equal(['bar:1|c'], inner_capture_sink.datagrams.map(&:source))
   end
 
   def test_using_a_different_datagram_class
     sink = StatsD::Instrument::CaptureSink.new(parent: [], datagram_class: String)
     sink << 'foo:1|c'
 
-    assert sink.datagrams.all? { |datagram| datagram.is_a?(String) }
-    assert_equal ['foo:1|c'], sink.datagrams
+    assert(sink.datagrams.all? { |datagram| datagram.is_a?(String) })
+    assert_equal(['foo:1|c'], sink.datagrams)
   end
 end

data/test/client_test.rb

@@ -19,25 +19,25 @@ class ClientTest < Minitest::Test
     )
     client = StatsD::Instrument::Client.from_env(env)
 
-    assert_equal 0.1, client.default_sample_rate
-    assert_equal 'foo', client.prefix
-    assert_equal ['shard:1', 'env:production'], client.default_tags
-    assert_equal StatsD::Instrument::StatsDDatagramBuilder, client.datagram_builder_class
+    assert_equal(0.1, client.default_sample_rate)
+    assert_equal('foo', client.prefix)
+    assert_equal(['shard:1', 'env:production'], client.default_tags)
+    assert_equal(StatsD::Instrument::StatsDDatagramBuilder, client.datagram_builder_class)
 
-    assert_kind_of StatsD::Instrument::UDPSink, client.sink
-    assert_equal '1.2.3.4', client.sink.host
-    assert_equal 8125, client.sink.port
+    assert_kind_of(StatsD::Instrument::UDPSink, client.sink)
+    assert_equal('1.2.3.4', client.sink.host)
+    assert_equal(8125, client.sink.port)
   end
 
   def test_client_from_env_has_sensible_defaults
     env = StatsD::Instrument::Environment.new({})
     client = StatsD::Instrument::Client.from_env(env)
 
-    assert_equal 1.0, client.default_sample_rate
-    assert_nil client.prefix
-    assert_nil client.default_tags
-    assert_equal StatsD::Instrument::DogStatsDDatagramBuilder, client.datagram_builder_class
-    assert_kind_of StatsD::Instrument::LogSink, client.sink
+    assert_equal(1.0, client.default_sample_rate)
+    assert_nil(client.prefix)
+    assert_nil(client.default_tags)
+    assert_equal(StatsD::Instrument::DogStatsDDatagramBuilder, client.datagram_builder_class)
+    assert_kind_of(StatsD::Instrument::LogSink, client.sink)
   end
 
   def test_client_from_env_with_overrides
@@ -51,12 +51,12 @@ class ClientTest < Minitest::Test
     client = StatsD::Instrument::Client.from_env(env,
       prefix: 'bar', implementation: 'dogstatsd', sink: StatsD::Instrument::NullSink.new)
 
-    assert_equal 0.1, client.default_sample_rate
-    assert_equal 'bar', client.prefix
-    assert_equal ['shard:1', 'env:production'], client.default_tags
-    assert_equal StatsD::Instrument::DogStatsDDatagramBuilder, client.datagram_builder_class
+    assert_equal(0.1, client.default_sample_rate)
+    assert_equal('bar', client.prefix)
+    assert_equal(['shard:1', 'env:production'], client.default_tags)
+    assert_equal(StatsD::Instrument::DogStatsDDatagramBuilder, client.datagram_builder_class)
 
-    assert_kind_of StatsD::Instrument::NullSink, client.sink
+    assert_kind_of(StatsD::Instrument::NullSink, client.sink)
   end
 
   def test_capture
@@ -71,27 +71,27 @@ class ClientTest < Minitest::Test
     end
     @client.increment('quc')
 
-    assert_equal ['bar', 'baz'], outer_datagrams.map(&:name)
-    assert_equal ['baz'], inner_datagrams.map(&:name)
+    assert_equal(['bar', 'baz'], outer_datagrams.map(&:name))
+    assert_equal(['baz'], inner_datagrams.map(&:name))
   end
 
   def test_metric_methods_return_truish_void
-    assert @client.increment('foo')
-    assert @client.measure('bar', 122.54)
-    assert @client.set('baz', 123)
-    assert @client.gauge('baz', 12.3)
+    assert(@client.increment('foo'))
+    assert(@client.measure('bar', 122.54))
+    assert(@client.set('baz', 123))
+    assert(@client.gauge('baz', 12.3))
   end
 
   def test_increment_with_default_value
     datagrams = @client.capture { @client.increment('foo') }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:1|c', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:1|c', datagrams.first.source)
   end
 
   def test_measure_with_value
     datagrams = @client.capture { @client.measure('foo', 122.54) }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:122.54|ms', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:122.54|ms', datagrams.first.source)
   end
 
   def test_measure_with_block
@@ -99,32 +99,32 @@ class ClientTest < Minitest::Test
     datagrams = @client.capture do
       @client.measure('foo') {}
     end
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:100.0|ms', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:100.0|ms', datagrams.first.source)
   end
 
   def test_gauge
     datagrams = @client.capture { @client.gauge('foo', 123) }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:123|g', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:123|g', datagrams.first.source)
   end
 
   def test_set
     datagrams = @client.capture { @client.set('foo', 12345) }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:12345|s', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:12345|s', datagrams.first.source)
   end
 
   def test_histogram
     datagrams = @dogstatsd_client.capture { @dogstatsd_client.histogram('foo', 12.44) }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:12.44|h', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:12.44|h', datagrams.first.source)
   end
 
   def test_distribution_with_value
     datagrams = @dogstatsd_client.capture { @dogstatsd_client.distribution('foo', 12.44) }
-    assert_equal 1, datagrams.size
-    assert_equal 'foo:12.44|d', datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal('foo:12.44|d', datagrams.first.source)
   end
 
   def test_distribution_with_block
@@ -132,8 +132,8 @@ class ClientTest < Minitest::Test
     datagrams = @dogstatsd_client.capture do
       @dogstatsd_client.distribution('foo') {}
     end
-    assert_equal 1, datagrams.size
-    assert_equal "foo:100.0|d", datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal("foo:100.0|d", datagrams.first.source)
   end
 
   def test_latency_emits_ms_metric
@@ -141,8 +141,8 @@ class ClientTest < Minitest::Test
     datagrams = @client.capture do
       @client.latency('foo') {}
     end
-    assert_equal 1, datagrams.size
-    assert_equal "foo:100.0|ms", datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal("foo:100.0|ms", datagrams.first.source)
   end
 
   def test_latency_on_dogstatsd_prefers_distribution_metric_type
@@ -150,8 +150,8 @@ class ClientTest < Minitest::Test
     datagrams = @dogstatsd_client.capture do
       @dogstatsd_client.latency('foo') {}
     end
-    assert_equal 1, datagrams.size
-    assert_equal "foo:100.0|d", datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal("foo:100.0|d", datagrams.first.source)
   end
 
   def test_latency_calls_block_even_when_not_sending_a_sample
@@ -159,19 +159,19 @@ class ClientTest < Minitest::Test
     @client.capture do
       @client.latency('foo', sample_rate: 0) { called = true }
     end
-    assert called, "The block should have been called"
+    assert(called, "The block should have been called")
   end
 
   def test_service_check
     datagrams = @dogstatsd_client.capture { @dogstatsd_client.service_check('service', :ok) }
-    assert_equal 1, datagrams.size
-    assert_equal "_sc|service|0", datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal("_sc|service|0", datagrams.first.source)
   end
 
   def test_event
     datagrams = @dogstatsd_client.capture { @dogstatsd_client.event('service', "event\ndescription") }
-    assert_equal 1, datagrams.size
-    assert_equal "_e{7,18}:service|event\\ndescription", datagrams.first.source
+    assert_equal(1, datagrams.size)
+    assert_equal("_e{7,18}:service|event\\ndescription", datagrams.first.source)
   end
 
   def test_no_prefix
@@ -181,9 +181,9 @@ class ClientTest < Minitest::Test
       client.increment('bar', no_prefix: true)
     end
 
-    assert_equal 2, datagrams.size
-    assert_equal "foo.bar", datagrams[0].name
-    assert_equal "bar", datagrams[1].name
+    assert_equal(2, datagrams.size)
+    assert_equal("foo.bar", datagrams[0].name)
+    assert_equal("bar", datagrams[1].name)
   end
 
   def test_default_tags_normalization
@@ -192,9 +192,9 @@ class ClientTest < Minitest::Test
       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'
+    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

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