statsd-instrument 3.0.0.pre1 → 3.1.0

data/test/benchmark/clock_gettime.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'benchmark/ips'
+require "benchmark/ips"
 
 Benchmark.ips do |bench|
   bench.report("Process.clock_gettime in milliseconds (int)") do

data/test/benchmark/default_tags.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require 'statsd-instrument'
-require 'benchmark/ips'
+require "statsd-instrument"
+require "benchmark/ips"
 
 StatsD.logger = Logger.new(File::NULL)
 
 class Suite
   def warming(*args)
     StatsD.default_tags = if args[0] == "with default tags"
-      { first_tag: 'first_value', second_tag: 'second_value' }
+      { first_tag: "first_value", second_tag: "second_value" }
     end
     puts "warming with default tags: #{StatsD.default_tags}"
   end
 
   def running(*args)
     StatsD.default_tags = if args[0] == "with default tags"
-      { first_tag: 'first_value', second_tag: 'second_value' }
+      { first_tag: "first_value", second_tag: "second_value" }
     end
     puts "running with default tags: #{StatsD.default_tags}"
   end
@@ -32,15 +32,15 @@ suite = Suite.new
 Benchmark.ips do |bench|
   bench.config(suite: suite)
   bench.report("without default tags") do
-    StatsD.increment('GoogleBase.insert', tags: {
-      first_tag: 'first_value',
-      second_tag: 'second_value',
-      third_tag: 'third_value',
+    StatsD.increment("GoogleBase.insert", tags: {
+      first_tag: "first_value",
+      second_tag: "second_value",
+      third_tag: "third_value",
     })
   end
 
   bench.report("with default tags") do
-    StatsD.increment('GoogleBase.insert', tags: { third_tag: 'third_value' })
+    StatsD.increment("GoogleBase.insert", tags: { third_tag: "third_value" })
   end
 
   bench.compare!

data/test/benchmark/metrics.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'statsd-instrument'
-require 'benchmark/ips'
+require "statsd-instrument"
+require "benchmark/ips"
 
 def helper_function
   a = 10
@@ -12,28 +12,28 @@ end
 
 Benchmark.ips do |bench|
   bench.report("increment metric benchmark") do
-    StatsD.increment('GoogleBase.insert', 10)
+    StatsD.increment("GoogleBase.insert", 10)
   end
 
   bench.report("measure metric benchmark") do
-    StatsD.measure('helper_function') do
+    StatsD.measure("helper_function") do
       helper_function
     end
   end
 
   bench.report("gauge metric benchmark") do
-    StatsD.gauge('GoogleBase.insert', 12)
+    StatsD.gauge("GoogleBase.insert", 12)
   end
 
   bench.report("set metric benchmark") do
-    StatsD.set('GoogleBase.customers', "12345", sample_rate: 1.0)
+    StatsD.set("GoogleBase.customers", "12345", sample_rate: 1.0)
   end
 
   bench.report("event metric benchmark") do
-    StatsD.event('Event Title', "12345")
+    StatsD.event("Event Title", "12345")
   end
 
   bench.report("service check metric benchmark") do
-    StatsD.service_check('shipit.redis_connection', 'ok')
+    StatsD.service_check("shipit.redis_connection", "ok")
   end
 end

data/test/benchmark/tags.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'statsd-instrument'
-require 'benchmark/ips'
+require "statsd-instrument"
+require "benchmark/ips"
 
 Benchmark.ips do |bench|
   bench.report("normalized tags with simple hash") do
-    StatsD::Instrument::Metric.normalize_tags(tag: 'value')
+    StatsD::Instrument::Metric.normalize_tags(tag: "value")
   end
 
   bench.report("normalized tags with simple array") do
-    StatsD::Instrument::Metric.normalize_tags(['test:test'])
+    StatsD::Instrument::Metric.normalize_tags(["test:test"])
   end
 
   bench.report("normalized tags with large hash") do

data/test/capture_sink_test.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class CaptureSinkTest < Minitest::Test
   def test_capture_sink_captures_datagram_instances
     capture_sink = StatsD::Instrument::CaptureSink.new(parent: [])
-    capture_sink << 'foo:1|c'
+    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
     parent = []
     capture_sink = StatsD::Instrument::CaptureSink.new(parent: parent)
-    capture_sink << 'foo:1|c' << 'bar:1|c'
+    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
@@ -25,18 +25,18 @@ class CaptureSinkTest < Minitest::Test
     outer_capture_sink = StatsD::Instrument::CaptureSink.new(parent: null_sink)
     inner_capture_sink = StatsD::Instrument::CaptureSink.new(parent: outer_capture_sink)
 
-    outer_capture_sink << 'foo:1|c'
-    inner_capture_sink << 'bar:1|c'
+    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'
+    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

@@ -1,222 +1,222 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class ClientTest < Minitest::Test
   def setup
     @client = StatsD::Instrument::Client.new(datagram_builder_class: StatsD::Instrument::StatsDDatagramBuilder)
-    @dogstatsd_client = StatsD::Instrument::Client.new(implementation: 'datadog')
+    @dogstatsd_client = StatsD::Instrument::Client.new(implementation: "datadog")
   end
 
   def test_client_from_env
     env = StatsD::Instrument::Environment.new(
-      'STATSD_ENV' => 'production',
-      'STATSD_SAMPLE_RATE' => '0.1',
-      'STATSD_PREFIX' => 'foo',
-      'STATSD_DEFAULT_TAGS' => 'shard:1,env:production',
-      'STATSD_IMPLEMENTATION' => 'statsd',
-      'STATSD_ADDR' => '1.2.3.4:8125',
+      "STATSD_ENV" => "production",
+      "STATSD_SAMPLE_RATE" => "0.1",
+      "STATSD_PREFIX" => "foo",
+      "STATSD_DEFAULT_TAGS" => "shard:1,env:production",
+      "STATSD_IMPLEMENTATION" => "statsd",
+      "STATSD_ADDR" => "1.2.3.4:8125",
     )
     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::BatchedUDPSink, 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
     env = StatsD::Instrument::Environment.new(
-      'STATSD_SAMPLE_RATE' => '0.1',
-      'STATSD_PREFIX' => 'foo',
-      'STATSD_DEFAULT_TAGS' => 'shard:1,env:production',
-      'STATSD_IMPLEMENTATION' => 'statsd',
-      'STATSD_ADDR' => '1.2.3.4:8125',
+      "STATSD_SAMPLE_RATE" => "0.1",
+      "STATSD_PREFIX" => "foo",
+      "STATSD_DEFAULT_TAGS" => "shard:1,env:production",
+      "STATSD_IMPLEMENTATION" => "statsd",
+      "STATSD_ADDR" => "1.2.3.4:8125",
     )
     client = StatsD::Instrument::Client.from_env(env,
-      prefix: 'bar', implementation: 'dogstatsd', sink: StatsD::Instrument::NullSink.new)
+      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
     inner_datagrams = nil
 
-    @client.increment('foo')
+    @client.increment("foo")
     outer_datagrams = @client.capture do
-      @client.increment('bar')
+      @client.increment("bar")
       inner_datagrams = @client.capture do
-        @client.increment('baz')
+        @client.increment("baz")
       end
     end
-    @client.increment('quc')
+    @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
+    datagrams = @client.capture { @client.increment("foo") }
+    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
+    datagrams = @client.capture { @client.measure("foo", 122.54) }
+    assert_equal(1, datagrams.size)
+    assert_equal("foo:122.54|ms", datagrams.first.source)
   end
 
   def test_measure_with_block
     Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
     datagrams = @client.capture do
-      @client.measure('foo') {}
+      @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
+    datagrams = @client.capture { @client.gauge("foo", 123) }
+    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
+    datagrams = @client.capture { @client.set("foo", 12345) }
+    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
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.histogram("foo", 12.44) }
+    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
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.distribution("foo", 12.44) }
+    assert_equal(1, datagrams.size)
+    assert_equal("foo:12.44|d", datagrams.first.source)
   end
 
   def test_distribution_with_block
     Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
     datagrams = @dogstatsd_client.capture do
-      @dogstatsd_client.distribution('foo') {}
+      @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
     Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
     datagrams = @client.capture do
-      @client.latency('foo') {}
+      @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
     Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
     datagrams = @dogstatsd_client.capture do
-      @dogstatsd_client.latency('foo') {}
+      @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
     called = false
     @client.capture do
-      @client.latency('foo', sample_rate: 0) { called = true }
+      @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
+    datagrams = @dogstatsd_client.capture { @dogstatsd_client.service_check("service", :ok) }
+    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
+    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)
   end
 
   def test_no_prefix
-    client = StatsD::Instrument::Client.new(prefix: 'foo')
+    client = StatsD::Instrument::Client.new(prefix: "foo")
     datagrams = client.capture do
-      client.increment('bar')
-      client.increment('bar', no_prefix: true)
+      client.increment("bar")
+      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
-    client = StatsD::Instrument::Client.new(default_tags: { first_tag: 'f|irst_value', second_tag: 'sec,ond_value' })
+    client = StatsD::Instrument::Client.new(default_tags: { first_tag: "f|irst_value", second_tag: "sec,ond_value" })
     datagrams = client.capture do
-      client.increment('bar', tags: ['th|ird_#,tag'])
+      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
-    mock_sink = mock('sink')
+    mock_sink = mock("sink")
     mock_sink.stubs(:sample?).returns(false, true, false, false, true)
     mock_sink.expects(:<<).twice
 
     client = StatsD::Instrument::Client.new(sink: mock_sink)
-    5.times { client.increment('metric') }
+    5.times { client.increment("metric") }
   end
 
   def test_clone_with_prefix_option
     # Both clients will use the same sink.
-    mock_sink = mock('sink')
+    mock_sink = mock("sink")
     mock_sink.stubs(:sample?).returns(true)
     mock_sink.expects(:<<).with("metric:1|c").returns(mock_sink)
     mock_sink.expects(:<<).with("foo.metric:1|c").returns(mock_sink)
 
     original_client = StatsD::Instrument::Client.new(sink: mock_sink)
-    client_with_other_options = original_client.clone_with_options(prefix: 'foo')
+    client_with_other_options = original_client.clone_with_options(prefix: "foo")
 
-    original_client.increment('metric')
-    client_with_other_options.increment('metric')
+    original_client.increment("metric")
+    client_with_other_options.increment("metric")
   end
 end