statsd-instrument 3.0.0.pre1 → 3.1.0

data/test/rubocop/splat_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class SplatArgumentsTest < Minitest::Test

data/test/statsd_datagram_builder_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class StatsDDatagramBuilderTest < Minitest::Test
   def setup
@@ -8,13 +8,13 @@ class StatsDDatagramBuilderTest < Minitest::Test
   end
 
   def test_raises_on_unsupported_metrics
-    assert_raises(NotImplementedError) { @datagram_builder.h('fo:o', 10, nil, nil) }
-    assert_raises(NotImplementedError) { @datagram_builder.d('fo:o', 10, nil, nil) }
-    assert_raises(NotImplementedError) { @datagram_builder.kv('fo:o', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.h("fo:o", 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.d("fo:o", 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.kv("fo:o", 10, nil, nil) }
   end
 
   def test_raises_when_using_tags
-    assert_raises(NotImplementedError) { @datagram_builder.c('fo:o', 10, nil, foo: 'bar') }
-    assert_raises(NotImplementedError) { StatsD::Instrument::StatsDDatagramBuilder.new(default_tags: ['foo']) }
+    assert_raises(NotImplementedError) { @datagram_builder.c("fo:o", 10, nil, foo: "bar") }
+    assert_raises(NotImplementedError) { StatsD::Instrument::StatsDDatagramBuilder.new(default_tags: ["foo"]) }
   end
 end

data/test/statsd_instrumentation_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class StatsDInstrumentationTest < Minitest::Test
   module ActiveMerchant
@@ -9,9 +9,9 @@ class StatsDInstrumentationTest < Minitest::Test
 
       def ssl_post(arg)
         if arg
-          'OK'
+          "OK"
         else
-          raise 'Not OK'
+          raise "Not OK"
         end
       end
 
@@ -46,7 +46,7 @@ class StatsDInstrumentationTest < Minitest::Test
 
   class GatewaySubClass < ActiveMerchant::Gateway
     def metric_name
-      'subgateway'
+      "subgateway"
     end
   end
 
@@ -55,126 +55,126 @@ class StatsDInstrumentationTest < Minitest::Test
 
     def public_and_instrumented
     end
-    statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+    statsd_count :public_and_instrumented, "InstrumentedClass.public_and_instrumented"
 
     protected
 
     def protected_and_instrumented
     end
-    statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+    statsd_count :protected_and_instrumented, "InstrumentedClass.protected_and_instrumented"
 
     private
 
     def private_and_instrumented
     end
-    statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
+    statsd_count :private_and_instrumented, "InstrumentedClass.private_and_instrumented"
   end
 
   include StatsD::Instrument::Assertions
 
   def test_statsd_count_if
-    ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
+    ActiveMerchant::Gateway.statsd_count_if(:ssl_post, "ActiveMerchant.Gateway.if")
 
-    assert_statsd_increment('ActiveMerchant.Gateway.if') do
+    assert_statsd_increment("ActiveMerchant.Gateway.if") do
       ActiveMerchant::Gateway.new.purchase(true)
       ActiveMerchant::Gateway.new.purchase(false)
     end
   ensure
-    ActiveMerchant::Gateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
+    ActiveMerchant::Gateway.statsd_remove_count_if(:ssl_post, "ActiveMerchant.Gateway.if")
   end
 
   def test_statsd_count_if_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
-      result == 'true'
+    ActiveMerchant::Base.statsd_count_if(:post_with_block, "ActiveMerchant.Base.post_with_block") do |result|
+      result == "true"
     end
 
-    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'true', ActiveMerchant::Base.new.post_with_block { 'true' }
-      assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
+    assert_statsd_increment("ActiveMerchant.Base.post_with_block") do
+      assert_equal("true", ActiveMerchant::Base.new.post_with_block { "true" })
+      assert_equal("false", ActiveMerchant::Base.new.post_with_block { "false" })
     end
   ensure
-    ActiveMerchant::Base.statsd_remove_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_remove_count_if(:post_with_block, "ActiveMerchant.Base.post_with_block")
   end
 
   def test_statsd_count_if_with_block
-    ActiveMerchant::UniqueGateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.block' do |result|
+    ActiveMerchant::UniqueGateway.statsd_count_if(:ssl_post, "ActiveMerchant.Gateway.block") do |result|
       result[:success]
     end
 
-    assert_statsd_increment('ActiveMerchant.Gateway.block', times: 1) do
+    assert_statsd_increment("ActiveMerchant.Gateway.block", times: 1) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
       ActiveMerchant::UniqueGateway.new.purchase(false)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.block'
+    ActiveMerchant::UniqueGateway.statsd_remove_count_if(:ssl_post, "ActiveMerchant.Gateway.block")
   end
 
   def test_statsd_count_success
-    ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', sample_rate: 0.5
+    ActiveMerchant::Gateway.statsd_count_success(:ssl_post, "ActiveMerchant.Gateway", sample_rate: 0.5)
 
-    assert_statsd_increment('ActiveMerchant.Gateway.success', sample_rate: 0.5, times: 1) do
+    assert_statsd_increment("ActiveMerchant.Gateway.success", sample_rate: 0.5, times: 1) do
       ActiveMerchant::Gateway.new.purchase(true)
       ActiveMerchant::Gateway.new.purchase(false)
     end
 
-    assert_statsd_increment('ActiveMerchant.Gateway.failure', sample_rate: 0.5, times: 1) do
+    assert_statsd_increment("ActiveMerchant.Gateway.failure", sample_rate: 0.5, times: 1) do
       ActiveMerchant::Gateway.new.purchase(false)
       ActiveMerchant::Gateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::Gateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
+    ActiveMerchant::Gateway.statsd_remove_count_success(:ssl_post, "ActiveMerchant.Gateway")
   end
 
   def test_statsd_count_success_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
-      result == 'successful'
+    ActiveMerchant::Base.statsd_count_success(:post_with_block, "ActiveMerchant.Base.post_with_block") do |result|
+      result == "successful"
     end
 
-    assert_statsd_increment('ActiveMerchant.Base.post_with_block.success', times: 1) do
-      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
-      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    assert_statsd_increment("ActiveMerchant.Base.post_with_block.success", times: 1) do
+      assert_equal("successful", ActiveMerchant::Base.new.post_with_block { "successful" })
+      assert_equal("not so successful", ActiveMerchant::Base.new.post_with_block { "not so successful" })
     end
 
-    assert_statsd_increment('ActiveMerchant.Base.post_with_block.failure', times: 1) do
-      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
-      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    assert_statsd_increment("ActiveMerchant.Base.post_with_block.failure", times: 1) do
+      assert_equal("successful", ActiveMerchant::Base.new.post_with_block { "successful" })
+      assert_equal("not so successful", ActiveMerchant::Base.new.post_with_block { "not so successful" })
     end
   ensure
-    ActiveMerchant::Base.statsd_remove_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_remove_count_success(:post_with_block, "ActiveMerchant.Base.post_with_block")
   end
 
   def test_statsd_count_success_with_block
-    ActiveMerchant::UniqueGateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway' do |result|
+    ActiveMerchant::UniqueGateway.statsd_count_success(:ssl_post, "ActiveMerchant.Gateway") do |result|
       result[:success]
     end
 
-    assert_statsd_increment('ActiveMerchant.Gateway.success') do
+    assert_statsd_increment("ActiveMerchant.Gateway.success") do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
 
-    assert_statsd_increment('ActiveMerchant.Gateway.failure') do
+    assert_statsd_increment("ActiveMerchant.Gateway.failure") do
       ActiveMerchant::UniqueGateway.new.purchase(false)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
+    ActiveMerchant::UniqueGateway.statsd_remove_count_success(:ssl_post, "ActiveMerchant.Gateway")
   end
 
   def test_statsd_count
-    ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::Gateway.statsd_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
 
-    assert_statsd_increment('ActiveMerchant.Gateway.ssl_post') do
+    assert_statsd_increment("ActiveMerchant.Gateway.ssl_post") do
       ActiveMerchant::Gateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_count_with_name_as_lambda
     metric_namer = lambda { |object, args| "#{object.metric_name}.#{args.first}" }
     ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
 
-    assert_statsd_increment('subgateway.foo') do
-      GatewaySubClass.new.purchase('foo')
+    assert_statsd_increment("subgateway.foo") do
+      GatewaySubClass.new.purchase("foo")
     end
   ensure
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
@@ -184,233 +184,233 @@ class StatsDInstrumentationTest < Minitest::Test
     metric_namer = proc { |object, args| "#{object.metric_name}.#{args.first}" }
     ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
 
-    assert_statsd_increment('subgateway.foo') do
-      GatewaySubClass.new.purchase('foo')
+    assert_statsd_increment("subgateway.foo") do
+      GatewaySubClass.new.purchase("foo")
     end
   ensure
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
   end
 
   def test_statsd_count_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_count(:post_with_block, "ActiveMerchant.Base.post_with_block")
 
-    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_increment("ActiveMerchant.Base.post_with_block") do
+      assert_equal("block called", ActiveMerchant::Base.new.post_with_block { "block called" })
     end
   ensure
-    ActiveMerchant::Base.statsd_remove_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_remove_count(:post_with_block, "ActiveMerchant.Base.post_with_block")
   end
 
   def test_statsd_measure
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
+    ActiveMerchant::UniqueGateway.statsd_measure(:ssl_post, "ActiveMerchant.Gateway.ssl_post", sample_rate: 0.3)
 
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
+    assert_statsd_measure("ActiveMerchant.Gateway.ssl_post", sample_rate: 0.3) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_measure(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_measure_uses_normalized_metric_name
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_measure(:ssl_post, "ActiveMerchant::Gateway.ssl_post")
 
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post') do
+    assert_statsd_measure("ActiveMerchant.Gateway.ssl_post") do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_measure(:ssl_post, "ActiveMerchant::Gateway.ssl_post")
   end
 
   def test_statsd_measure_raises_without_a_provided_block
     assert_raises(LocalJumpError) do
-      assert_statsd_measure('ActiveMerchant.Gateway.ssl_post')
+      assert_statsd_measure("ActiveMerchant.Gateway.ssl_post")
     end
   end
 
   def test_statsd_measure_with_method_receiving_block
-    ActiveMerchant::Base.statsd_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_measure(:post_with_block, "ActiveMerchant.Base.post_with_block")
 
-    assert_statsd_measure('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_measure("ActiveMerchant.Base.post_with_block") do
+      assert_equal("block called", ActiveMerchant::Base.new.post_with_block { "block called" })
     end
   ensure
-    ActiveMerchant::Base.statsd_remove_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_remove_measure(:post_with_block, "ActiveMerchant.Base.post_with_block")
   end
 
   def test_statsd_measure_with_sample_rate
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1
+    ActiveMerchant::UniqueGateway.statsd_measure(:ssl_post, "ActiveMerchant.Gateway.ssl_post", sample_rate: 0.1)
 
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1) do
+    assert_statsd_measure("ActiveMerchant.Gateway.ssl_post", sample_rate: 0.1) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_measure(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_distribution
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
+    ActiveMerchant::UniqueGateway.statsd_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post", sample_rate: 0.3)
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
+    assert_statsd_distribution("ActiveMerchant.Gateway.ssl_post", sample_rate: 0.3) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_distribution_uses_normalized_metric_name
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_distribution(:ssl_post, "ActiveMerchant::Gateway.ssl_post")
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
+    assert_statsd_distribution("ActiveMerchant.Gateway.ssl_post") do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_distribution(:ssl_post, "ActiveMerchant::Gateway.ssl_post")
   end
 
   def test_statsd_distribution_raises_without_a_provided_block
     assert_raises(LocalJumpError) do
-      assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post')
+      assert_statsd_distribution("ActiveMerchant.Gateway.ssl_post")
     end
   end
 
   def test_statsd_distribution_with_method_receiving_block
-    ActiveMerchant::Base.statsd_distribution :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_distribution(:post_with_block, "ActiveMerchant.Base.post_with_block")
 
-    assert_statsd_distribution('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_distribution("ActiveMerchant.Base.post_with_block") do
+      assert_equal("block called", ActiveMerchant::Base.new.post_with_block { "block called" })
     end
   ensure
-    ActiveMerchant::Base.statsd_remove_distribution :post_with_block, 'ActiveMerchant.Base.post_with_block'
+    ActiveMerchant::Base.statsd_remove_distribution(:post_with_block, "ActiveMerchant.Base.post_with_block")
   end
 
   def test_statsd_distribution_with_tags
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', tags: ['foo']
+    ActiveMerchant::UniqueGateway.statsd_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post", tags: ["foo"])
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', tags: ['foo']) do
+    assert_statsd_distribution("ActiveMerchant.Gateway.ssl_post", tags: ["foo"]) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_distribution_with_sample_rate
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1
+    ActiveMerchant::UniqueGateway.statsd_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post", sample_rate: 0.1)
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1) do
+    assert_statsd_distribution("ActiveMerchant.Gateway.ssl_post", sample_rate: 0.1) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_distribution(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_instrumenting_class_method
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
+    ActiveMerchant::Gateway.singleton_class.extend(StatsD::Instrument)
+    ActiveMerchant::Gateway.singleton_class.statsd_count(:sync, "ActiveMerchant.Gateway.sync")
 
-    assert_statsd_increment('ActiveMerchant.Gateway.sync') do
+    assert_statsd_increment("ActiveMerchant.Gateway.sync") do
       ActiveMerchant::Gateway.sync
     end
   ensure
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count(:sync, "ActiveMerchant.Gateway.sync")
   end
 
   def test_statsd_count_with_tags
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync', tags: { key: 'value' }
+    ActiveMerchant::Gateway.singleton_class.extend(StatsD::Instrument)
+    ActiveMerchant::Gateway.singleton_class.statsd_count(:sync, "ActiveMerchant.Gateway.sync", tags: { key: "value" })
 
-    assert_statsd_increment('ActiveMerchant.Gateway.sync', tags: ['key:value']) do
+    assert_statsd_increment("ActiveMerchant.Gateway.sync", tags: ["key:value"]) do
       ActiveMerchant::Gateway.sync
     end
   ensure
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count(:sync, "ActiveMerchant.Gateway.sync")
   end
 
   def test_statsd_respects_global_prefix_changes
     old_client = StatsD.singleton_client
 
-    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: 'Foo')
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
-    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: 'Quc')
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: "Foo")
+    ActiveMerchant::Gateway.singleton_class.extend(StatsD::Instrument)
+    ActiveMerchant::Gateway.singleton_class.statsd_count(:sync, "ActiveMerchant.Gateway.sync")
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: "Quc")
 
     datagrams = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, datagrams.length
-    assert_equal "Quc.ActiveMerchant.Gateway.sync", datagrams.first.name
+    assert_equal(1, datagrams.length)
+    assert_equal("Quc.ActiveMerchant.Gateway.sync", datagrams.first.name)
   ensure
     StatsD.singleton_client = old_client
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count(:sync, "ActiveMerchant.Gateway.sync")
   end
 
   def test_statsd_count_with_injected_client
-    client = StatsD::Instrument::Client.new(prefix: 'prefix')
+    client = StatsD::Instrument::Client.new(prefix: "prefix")
 
-    ActiveMerchant::Gateway.statsd_count(:ssl_post, 'ActiveMerchant.Gateway.ssl_post', client: client)
-    assert_statsd_increment('prefix.ActiveMerchant.Gateway.ssl_post', client: client) do
+    ActiveMerchant::Gateway.statsd_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post", client: client)
+    assert_statsd_increment("prefix.ActiveMerchant.Gateway.ssl_post", client: client) do
       ActiveMerchant::Gateway.new.purchase(true)
     end
   ensure
-    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
   end
 
   def test_statsd_macro_can_disable_prefix
-    client = StatsD::Instrument::Client.new(prefix: 'foo')
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
+    client = StatsD::Instrument::Client.new(prefix: "foo")
+    ActiveMerchant::Gateway.singleton_class.extend(StatsD::Instrument)
     ActiveMerchant::Gateway.singleton_class.statsd_count_success(:sync,
-      'ActiveMerchant.Gateway.sync', no_prefix: true, client: client)
+      "ActiveMerchant.Gateway.sync", no_prefix: true, client: client)
 
     datagrams = client.capture { ActiveMerchant::Gateway.sync }
-    assert_equal 1, datagrams.length
-    assert_equal "ActiveMerchant.Gateway.sync.success", datagrams.first.name
+    assert_equal(1, datagrams.length)
+    assert_equal("ActiveMerchant.Gateway.sync.success", datagrams.first.name)
   ensure
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_count_success :sync, 'ActiveMerchant.Gateway.sync'
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count_success(:sync, "ActiveMerchant.Gateway.sync")
   end
 
   def test_statsd_doesnt_change_method_scope_of_public_method
-    assert_scope InstrumentedClass, :public_and_instrumented, :public
+    assert_scope(InstrumentedClass, :public_and_instrumented, :public)
 
-    assert_statsd_increment('InstrumentedClass.public_and_instrumented') do
+    assert_statsd_increment("InstrumentedClass.public_and_instrumented") do
       InstrumentedClass.new.send(:public_and_instrumented)
     end
   end
 
   def test_statsd_doesnt_change_method_scope_of_protected_method
-    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
+    assert_scope(InstrumentedClass, :protected_and_instrumented, :protected)
 
-    assert_statsd_increment('InstrumentedClass.protected_and_instrumented') do
+    assert_statsd_increment("InstrumentedClass.protected_and_instrumented") do
       InstrumentedClass.new.send(:protected_and_instrumented)
     end
   end
 
   def test_statsd_doesnt_change_method_scope_of_private_method
-    assert_scope InstrumentedClass, :private_and_instrumented, :private
+    assert_scope(InstrumentedClass, :private_and_instrumented, :private)
 
-    assert_statsd_increment('InstrumentedClass.private_and_instrumented') do
+    assert_statsd_increment("InstrumentedClass.private_and_instrumented") do
       InstrumentedClass.new.send(:private_and_instrumented)
     end
   end
 
   def test_statsd_doesnt_change_method_scope_on_removal_of_public_method
-    assert_scope InstrumentedClass, :public_and_instrumented, :public
-    InstrumentedClass.statsd_remove_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
-    assert_scope InstrumentedClass, :public_and_instrumented, :public
+    assert_scope(InstrumentedClass, :public_and_instrumented, :public)
+    InstrumentedClass.statsd_remove_count(:public_and_instrumented, "InstrumentedClass.public_and_instrumented")
+    assert_scope(InstrumentedClass, :public_and_instrumented, :public)
 
-    InstrumentedClass.statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+    InstrumentedClass.statsd_count(:public_and_instrumented, "InstrumentedClass.public_and_instrumented")
   end
 
   def test_statsd_doesnt_change_method_scope_on_removal_of_protected_method
-    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
-    InstrumentedClass.statsd_remove_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
-    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
+    assert_scope(InstrumentedClass, :protected_and_instrumented, :protected)
+    InstrumentedClass.statsd_remove_count(:protected_and_instrumented, "InstrumentedClass.protected_and_instrumented")
+    assert_scope(InstrumentedClass, :protected_and_instrumented, :protected)
 
-    InstrumentedClass.statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+    InstrumentedClass.statsd_count(:protected_and_instrumented, "InstrumentedClass.protected_and_instrumented")
   end
 
   def test_statsd_doesnt_change_method_scope_on_removal_of_private_method
-    assert_scope InstrumentedClass, :private_and_instrumented, :private
-    InstrumentedClass.statsd_remove_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
-    assert_scope InstrumentedClass, :private_and_instrumented, :private
+    assert_scope(InstrumentedClass, :private_and_instrumented, :private)
+    InstrumentedClass.statsd_remove_count(:private_and_instrumented, "InstrumentedClass.private_and_instrumented")
+    assert_scope(InstrumentedClass, :private_and_instrumented, :private)
 
-    InstrumentedClass.statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
+    InstrumentedClass.statsd_count(:private_and_instrumented, "InstrumentedClass.private_and_instrumented")
   end
 
   def test_statsd_works_with_prepended_modules
@@ -440,6 +440,6 @@ class StatsDInstrumentationTest < Minitest::Test
       :public
     end
 
-    assert_equal method_scope, expected_scope, "Expected method to be #{expected_scope}"
+    assert_equal(method_scope, expected_scope, "Expected method to be #{expected_scope}")
   end
 end