statsd-instrument 3.0.0.pre2 → 3.1.1

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)
-    assert_equal "foo:1|c", datagram
+    datagram = @datagram_builder.c("foo", 1, nil, nil)
+    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
+    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)
-    assert_equal "foo:1|ms", datagram
+    datagram = @datagram_builder.ms("foo", 1, nil, nil)
+    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
+    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)
-    assert_equal "foo:1|g", datagram
+    datagram = @datagram_builder.g("foo", 1, nil, nil)
+    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
+    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)
-    assert_equal "foo:1|s", datagram
+    datagram = @datagram_builder.s("foo", 1, nil, nil)
+    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
+    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)
-    assert_equal "foo:1|h", datagram
+    datagram = @datagram_builder.h("foo", 1, nil, nil)
+    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
+    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)
-    assert_equal "foo:1|d", datagram
+    datagram = @datagram_builder.d("foo", 1, nil, nil)
+    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
+    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'])
-    assert_equal "foo:10|d|#foo,bar", datagram
+    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'])
-    assert_equal "foo:10|d|@0.1|#foo:bar", datagram
+    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')
-    assert_equal "foo:10|d|#foo:bar,baz:quc", datagram
+    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

data/test/datagram_test.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class DatagramTest < Minitest::Test
   def test_parsing_datagrams
-    datagram = 'Kernel.Orders.order_creation_path:1|c|' \
-      '#order_source:web,code_source:NilController#NilAction,order_builder:false,' \
-      'multi_currency:false,fulfillment_orders_beta_enabled:false'
+    datagram = "Kernel.Orders.order_creation_path:1|c|" \
+      "#order_source:web,code_source:NilController#NilAction,order_builder:false," \
+      "multi_currency:false,fulfillment_orders_beta_enabled:false"
 
     parsed = StatsD::Instrument::Datagram.new(datagram)
-    assert_includes parsed.tags, 'code_source:NilController#NilAction'
+    assert_includes(parsed.tags, "code_source:NilController#NilAction")
   end
 end

data/test/dogstatsd_datagram_builder_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class DogStatsDDatagramBuilderTest < Minitest::Test
   def setup
@@ -8,60 +8,60 @@ class DogStatsDDatagramBuilderTest < Minitest::Test
   end
 
   def test_raises_on_unsupported_metrics
-    assert_raises(NotImplementedError) { @datagram_builder.kv('foo', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.kv("foo", 10, nil, nil) }
   end
 
   def test_simple_service_check
-    datagram = @datagram_builder._sc('service', :ok)
-    assert_equal '_sc|service|0', datagram
+    datagram = @datagram_builder._sc("service", :ok)
+    assert_equal("_sc|service|0", datagram)
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 0, parsed_datagram.value
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal("service", parsed_datagram.name)
+    assert_equal(0, parsed_datagram.value)
   end
 
   def test_complex_service_check
-    datagram = @datagram_builder._sc('service', :warning, timestamp: Time.parse('2019-09-30T04:22:12Z'),
-      hostname: 'localhost', tags: { foo: 'bar|baz' }, message: 'blah')
-    assert_equal "_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram
+    datagram = @datagram_builder._sc("service", :warning, timestamp: Time.parse("2019-09-30T04:22:12Z"),
+      hostname: "localhost", tags: { foo: "bar|baz" }, message: "blah")
+    assert_equal("_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 1, parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal 'blah', parsed_datagram.message
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal("service", parsed_datagram.name)
+    assert_equal(1, parsed_datagram.value)
+    assert_equal("localhost", parsed_datagram.hostname)
+    assert_equal(Time.parse("2019-09-30T04:22:12Z"), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal("blah", parsed_datagram.message)
   end
 
   def test_simple_event
-    datagram = @datagram_builder._e('hello', "world")
-    assert_equal '_e{5,5}:hello|world', datagram
+    datagram = @datagram_builder._e("hello", "world")
+    assert_equal("_e{5,5}:hello|world", datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'hello', parsed_datagram.name
-    assert_equal 'world', parsed_datagram.value
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal("hello", parsed_datagram.name)
+    assert_equal("world", parsed_datagram.value)
   end
 
   def test_complex_event
-    datagram = @datagram_builder._e("testing", "with\nnewline", timestamp: Time.parse('2019-09-30T04:22:12Z'),
-      hostname: 'localhost', aggregation_key: 'my-key', priority: 'low', source_type_name: 'source',
-      alert_type: 'success', tags: { foo: 'bar|baz' })
-    assert_equal '_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
-      'p:low|s:source|t:success|#foo:barbaz', datagram
+    datagram = @datagram_builder._e("testing", "with\nnewline", timestamp: Time.parse("2019-09-30T04:22:12Z"),
+      hostname: "localhost", aggregation_key: "my-key", priority: "low", source_type_name: "source",
+      alert_type: "success", tags: { foo: "bar|baz" })
+    assert_equal('_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
+      "p:low|s:source|t:success|#foo:barbaz", datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'testing', parsed_datagram.name
-    assert_equal "with\nnewline", parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal "my-key", parsed_datagram.aggregation_key
-    assert_equal "low", parsed_datagram.priority
-    assert_equal "source", parsed_datagram.source_type_name
-    assert_equal "success", parsed_datagram.alert_type
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal("testing", parsed_datagram.name)
+    assert_equal("with\nnewline", parsed_datagram.value)
+    assert_equal("localhost", parsed_datagram.hostname)
+    assert_equal(Time.parse("2019-09-30T04:22:12Z"), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal("my-key", parsed_datagram.aggregation_key)
+    assert_equal("low", parsed_datagram.priority)
+    assert_equal("source", parsed_datagram.source_type_name)
+    assert_equal("success", parsed_datagram.alert_type)
   end
 end

data/test/environment_test.rb

@@ -1,58 +1,67 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 module Rails; end
 
 class EnvironmentTest < Minitest::Test
   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',
+      "STATSD_ENV" => "set_from_STATSD_ENV",
+      "RACK_ENV" => "set_from_RACK_ENV",
+      "ENV" => "set_from_ENV",
     )
-    assert_equal 'set_from_STATSD_ENV', env.environment
+    assert_equal("set_from_STATSD_ENV", env.environment)
   end
 
   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',
+      "ENV" => "set_from_ENV",
     )
-    assert_equal 'set_from_ENV', env.environment
+    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
+    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
+    assert_equal("development", env.environment)
   end
 
   def test_client_returns_client_instance
     env = StatsD::Instrument::Environment.new({})
-    assert_kind_of StatsD::Instrument::Client, env.client
+    assert_kind_of(StatsD::Instrument::Client, env.client)
   end
 
   def test_client_from_env_uses_log_sink_in_development_environment
-    env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'development')
-    assert_kind_of StatsD::Instrument::LogSink, env.client.sink
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "development")
+    assert_kind_of(StatsD::Instrument::LogSink, env.client.sink)
   end
 
   def test_client_from_env_uses_null_sink_in_test_environment
-    env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'test')
-    assert_kind_of StatsD::Instrument::NullSink, env.client.sink
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "test")
+    assert_kind_of(StatsD::Instrument::NullSink, env.client.sink)
   end
 
-  def test_client_from_env_uses_udp_sink_in_staging_environment
-    env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'staging')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+  def test_client_from_env_uses_batched_udp_sink_in_staging_environment
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "staging")
+    assert_kind_of(StatsD::Instrument::BatchedUDPSink, env.client.sink)
   end
 
-  def test_client_from_env_uses_udp_sink_in_production_environment
-    env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'production')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+  def test_client_from_env_uses_batched_udp_sink_in_production_environment
+    env = StatsD::Instrument::Environment.new("STATSD_USE_NEW_CLIENT" => "1", "STATSD_ENV" => "production")
+    assert_kind_of(StatsD::Instrument::BatchedUDPSink, env.client.sink)
+  end
+
+  def test_client_from_env_uses_regular_udp_sink_when_flush_interval_is_0
+    env = StatsD::Instrument::Environment.new(
+      "STATSD_USE_NEW_CLIENT" => "1",
+      "STATSD_ENV" => "staging",
+      "STATSD_FLUSH_INTERVAL" => "0.0",
+    )
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 end

data/test/helpers/rubocop_helper.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
+require "rubocop/cop/legacy/corrector"
 
 module RubocopHelper
   attr_accessor :cop
 
   private
 
+  RUBY_VERSION = 2.5
+  private_constant :RUBY_VERSION
+
   def assert_no_offenses(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    assert_predicate cop.offenses, :empty?, "Did not expect Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    assert_predicate(cop.offenses, :empty?, "Did not expect Rubocop to find offenses")
   end
 
   def assert_offense(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    refute_predicate cop.offenses, :empty?, "Expected Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    refute_predicate(cop.offenses, :empty?, "Expected Rubocop to find offenses")
   end
 
   def assert_no_autocorrect(source)
     corrected = autocorrect_source(source)
-    assert_equal source, corrected
+    assert_equal(source, corrected)
   end
 
   def autocorrect_source(source)
@@ -27,16 +31,15 @@ module RubocopHelper
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
     cop.instance_variable_get(:@options)[:auto_correct] = true
 
-    processed_source = RuboCop::ProcessedSource.new(source, 2.3, nil)
+    processed_source = RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil)
     investigate(processed_source)
 
-    corrector = RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector = RuboCop::Cop::Legacy::Corrector.new(processed_source.buffer, cop.corrections)
     corrector.rewrite
   end
 
   def investigate(processed_source)
     forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
-      next unless cop.join_force?(klass)
       instances << klass.new([cop])
     end
 

data/test/helpers_test.rb

@@ -1,40 +1,40 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class HelpersTest < Minitest::Test
   def setup
     test_class = Class.new(Minitest::Test)
     test_class.send(:include, StatsD::Instrument::Helpers)
-    @test_case = test_class.new('fake')
+    @test_case = test_class.new("fake")
   end
 
   def test_capture_metrics_inside_block_only
-    StatsD.increment('counter')
+    StatsD.increment("counter")
     metrics = @test_case.capture_statsd_calls do
-      StatsD.increment('counter')
-      StatsD.gauge('gauge', 12)
+      StatsD.increment("counter")
+      StatsD.gauge("gauge", 12)
     end
-    StatsD.gauge('gauge', 15)
+    StatsD.gauge("gauge", 15)
 
-    assert_equal 2, metrics.length
-    assert_equal 'counter', metrics[0].name
-    assert_equal 'gauge', metrics[1].name
-    assert_equal 12, metrics[1].value
+    assert_equal(2, metrics.length)
+    assert_equal("counter", metrics[0].name)
+    assert_equal("gauge", metrics[1].name)
+    assert_equal(12, metrics[1].value)
   end
 
   def test_capture_metrics_with_new_client
     @old_client = StatsD.singleton_client
     StatsD.singleton_client = StatsD::Instrument::Client.new
 
-    StatsD.increment('counter')
+    StatsD.increment("counter")
     metrics = @test_case.capture_statsd_datagrams do
-      StatsD.increment('counter')
-      StatsD.gauge('gauge', 12)
+      StatsD.increment("counter")
+      StatsD.gauge("gauge", 12)
     end
-    StatsD.gauge('gauge', 15)
+    StatsD.gauge("gauge", 15)
 
-    assert_equal 2, metrics.length
+    assert_equal(2, metrics.length)
 
   ensure
     StatsD.singleton_client = @old_client