statsd-instrument 3.0.2 → 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("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_equal(["foo:1|c"], sink.datagrams)
   end
 end

data/test/client_test.rb

@@ -1,31 +1,31 @@
 # 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("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_kind_of(StatsD::Instrument::BatchedUDPSink, client.sink)
+    assert_equal("1.2.3.4", client.sink.host)
     assert_equal(8125, client.sink.port)
   end
 
@@ -42,18 +42,18 @@ class ClientTest < Minitest::Test
 
   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("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)
@@ -62,75 +62,75 @@ class ClientTest < Minitest::Test
   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') }
+    datagrams = @client.capture { @client.increment("foo") }
     assert_equal(1, datagrams.size)
-    assert_equal('foo:1|c', datagrams.first.source)
+    assert_equal("foo:1|c", datagrams.first.source)
   end
 
   def test_measure_with_value
-    datagrams = @client.capture { @client.measure('foo', 122.54) }
+    datagrams = @client.capture { @client.measure("foo", 122.54) }
     assert_equal(1, datagrams.size)
-    assert_equal('foo:122.54|ms', datagrams.first.source)
+    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("foo:100.0|ms", datagrams.first.source)
   end
 
   def test_gauge
-    datagrams = @client.capture { @client.gauge('foo', 123) }
+    datagrams = @client.capture { @client.gauge("foo", 123) }
     assert_equal(1, datagrams.size)
-    assert_equal('foo:123|g', datagrams.first.source)
+    assert_equal("foo:123|g", datagrams.first.source)
   end
 
   def test_set
-    datagrams = @client.capture { @client.set('foo', 12345) }
+    datagrams = @client.capture { @client.set("foo", 12345) }
     assert_equal(1, datagrams.size)
-    assert_equal('foo:12345|s', datagrams.first.source)
+    assert_equal("foo:12345|s", datagrams.first.source)
   end
 
   def test_histogram
-    datagrams = @dogstatsd_client.capture { @dogstatsd_client.histogram('foo', 12.44) }
+    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("foo:12.44|h", datagrams.first.source)
   end
 
   def test_distribution_with_value
-    datagrams = @dogstatsd_client.capture { @dogstatsd_client.distribution('foo', 12.44) }
+    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("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)
@@ -139,7 +139,7 @@ class ClientTest < Minitest::Test
   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)
@@ -148,7 +148,7 @@ class ClientTest < Minitest::Test
   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)
@@ -157,28 +157,28 @@ class ClientTest < Minitest::Test
   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")
   end
 
   def test_service_check
-    datagrams = @dogstatsd_client.capture { @dogstatsd_client.service_check('service', :ok) }
+    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") }
+    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)
@@ -187,36 +187,36 @@ class ClientTest < Minitest::Test
   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

data/test/datagram_builder_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class DatagramBuilderTest < Minitest::Test
   def setup
@@ -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)
+    datagram = @datagram_builder.c("foo", 1, nil, nil)
     assert_equal("foo:1|c", datagram)
 
-    datagram = @datagram_builder.c('fo:o', 10, 0.1, nil)
+    datagram = @datagram_builder.c("fo:o", 10, 0.1, nil)
     assert_equal("fo_o:10|c|@0.1", datagram)
   end
 
   def test_ms
-    datagram = @datagram_builder.ms('foo', 1, nil, nil)
+    datagram = @datagram_builder.ms("foo", 1, nil, nil)
     assert_equal("foo:1|ms", datagram)
 
-    datagram = @datagram_builder.ms('fo:o', 10, 0.1, nil)
+    datagram = @datagram_builder.ms("fo:o", 10, 0.1, nil)
     assert_equal("fo_o:10|ms|@0.1", datagram)
   end
 
   def test_g
-    datagram = @datagram_builder.g('foo', 1, nil, nil)
+    datagram = @datagram_builder.g("foo", 1, nil, nil)
     assert_equal("foo:1|g", datagram)
 
-    datagram = @datagram_builder.g('fo|o', 10, 0.01, nil)
+    datagram = @datagram_builder.g("fo|o", 10, 0.01, nil)
     assert_equal("fo_o:10|g|@0.01", datagram)
   end
 
   def test_s
-    datagram = @datagram_builder.s('foo', 1, nil, nil)
+    datagram = @datagram_builder.s("foo", 1, nil, nil)
     assert_equal("foo:1|s", datagram)
 
-    datagram = @datagram_builder.s('fo@o', 10, 0.01, nil)
+    datagram = @datagram_builder.s("fo@o", 10, 0.01, nil)
     assert_equal("fo_o:10|s|@0.01", datagram)
   end
 
   def test_h
-    datagram = @datagram_builder.h('foo', 1, nil, nil)
+    datagram = @datagram_builder.h("foo", 1, nil, nil)
     assert_equal("foo:1|h", datagram)
 
-    datagram = @datagram_builder.h('fo@o', 10, 0.01, nil)
+    datagram = @datagram_builder.h("fo@o", 10, 0.01, nil)
     assert_equal("fo_o:10|h|@0.01", datagram)
   end
 
   def test_d
-    datagram = @datagram_builder.d('foo', 1, nil, nil)
+    datagram = @datagram_builder.d("foo", 1, nil, nil)
     assert_equal("foo:1|d", datagram)
 
-    datagram = @datagram_builder.d('fo@o', 10, 0.01, nil)
+    datagram = @datagram_builder.d("fo@o", 10, 0.01, nil)
     assert_equal("fo_o:10|d|@0.01", datagram)
   end
 
   def test_tags
-    datagram = @datagram_builder.d('foo', 10, nil, ['foo', 'bar'])
+    datagram = @datagram_builder.d("foo", 10, nil, ["foo", "bar"])
     assert_equal("foo:10|d|#foo,bar", datagram)
 
-    datagram = @datagram_builder.d('foo', 10, 0.1, ['foo:bar'])
+    datagram = @datagram_builder.d("foo", 10, 0.1, ["foo:bar"])
     assert_equal("foo:10|d|@0.1|#foo:bar", datagram)
 
-    datagram = @datagram_builder.d('foo', 10, 1, foo: 'bar', baz: 'quc')
+    datagram = @datagram_builder.d("foo", 10, 1, foo: "bar", baz: "quc")
     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)
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(prefix: "foo")
+    datagram = datagram_builder.c("bar", 1, nil, nil)
+    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)
+    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)
   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)
+    datagram_builder = StatsD::Instrument::DatagramBuilder.new(default_tags: ["foo"])
+    datagram = datagram_builder.c("bar", 1, nil, nil)
+    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)
+    datagram = datagram_builder.c("bar", 1, nil, a: "b")
+    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)
+    datagram = datagram_builder.c("bar", 1, nil, ["foo"])
+    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)
+    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)
   end
 end