statsd-instrument 2.9.2 → 3.0.2

data/test/log_sink_test.rb

@@ -12,7 +12,7 @@ class LogSinkTest < Minitest::Test
     log_sink = StatsD::Instrument::LogSink.new(logger)
     log_sink << 'foo:1|c' << 'bar:1|c'
 
-    assert_equal <<~LOG, log.string
+    assert_equal(<<~LOG, log.string)
       DEBUG: [StatsD] foo:1|c
       DEBUG: [StatsD] bar:1|c
     LOG
@@ -27,7 +27,7 @@ class LogSinkTest < Minitest::Test
     log_sink = StatsD::Instrument::LogSink.new(logger)
     log_sink << "foo:1|c\n" << "bar:1|c\n"
 
-    assert_equal <<~LOG, log.string
+    assert_equal(<<~LOG, log.string)
       DEBUG: [StatsD] foo:1|c
       DEBUG: [StatsD] bar:1|c
     LOG

data/test/matchers_test.rb

@@ -5,112 +5,112 @@ require 'statsd/instrument/matchers'
 
 class MatchersTest < Minitest::Test
   def test_statsd_increment_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('not_counter') })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('not_counter') }))
   end
 
   def test_statsd_increment_compound_matched
     matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
     matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
 
-    assert RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches? lambda {
+    assert(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
       StatsD.increment('counter', tags: ['a'])
       StatsD.increment('counter', tags: ['b'])
-    }
+    }))
   end
 
   def test_statsd_increment_compound_not_matched
     matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
     matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
 
-    refute RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches? lambda {
+    refute(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
       StatsD.increment('counter', tags: ['a'])
       StatsD.increment('counter', tags: ['a'])
-    }
+    }))
   end
 
   def test_statsd_increment_with_times_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_times_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
-      .matches? lambda { 3.times { StatsD.increment('counter') } }
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
+      .matches?(lambda { 3.times { StatsD.increment('counter') } }))
   end
 
   def test_statsd_increment_with_sample_rate_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
   end
 
   def test_statsd_increment_with_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_value_matched_when_multiple_metrics
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', 2)
       StatsD.increment('counter', 1)
-    })
+    }))
   end
 
   def test_statsd_increment_with_value_not_matched_when_multiple_metrics
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', 2)
       StatsD.increment('counter', 3)
-    })
+    }))
   end
 
   def test_statsd_increment_with_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
-      .matches?(lambda { StatsD.increment('counter') })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_tags_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) }))
   end
 
   def test_statsd_increment_with_tags_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['c']) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['c']) }))
   end
 
   def test_statsd_increment_with_times_and_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', 1)
       StatsD.increment('counter', 1)
-    })
+    }))
   end
 
   def test_statsd_increment_with_times_and_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', 1)
       StatsD.increment('counter', 2)
-    })
+    }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_not_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
   end
 end

data/test/null_sink_test.rb

@@ -11,7 +11,7 @@ class NullSinkTest < Minitest::Test
 
   def test_null_sink_sample
     null_sink = StatsD::Instrument::NullSink.new
-    assert null_sink.sample?(0), "The null sink should always sample"
-    assert null_sink.sample?(1), "The null sink should always sample"
+    assert(null_sink.sample?(0), "The null sink should always sample")
+    assert(null_sink.sample?(1), "The null sink should always sample")
   end
 end

data/test/rubocop/metric_return_value_test.rb

@@ -21,14 +21,14 @@ module Rubocop
     end
 
     def test_ok_as_multiple_statement
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         StatsD.increment 'foo'
         StatsD.increment 'bar'
       RUBY
     end
 
     def test_ok_inside_block
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         block do
           StatsD.measure
         end
@@ -44,7 +44,7 @@ module Rubocop
     end
 
     def test_ok_when_passing_do_end_block
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         block_result = StatsD.measure('foo') do
           return_something_useful
         end

data/test/rubocop/metric_value_keyword_argument_test.rb

@@ -31,7 +31,7 @@ module Rubocop
     def test_offense_with_value_keyword
       assert_offense("StatsD.increment('foo', value: 1)")
       assert_offense("StatsD.increment('foo', :value => 1)")
-      assert_offense("StatsD.increment('foo', 'value' => 1)")
+      # assert_offense("StatsD.increment('foo', 'value' => 1)")
       assert_offense("StatsD.increment('foo', sample_rate: 0.1, value: 1, tags: ['foo'])")
       assert_offense("StatsD.increment('foo', value: 1, &block)")
     end

data/test/rubocop/positional_arguments_test.rb

@@ -51,47 +51,47 @@ module Rubocop
 
     def test_autocorrect_only_sample_rate
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5)")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5)", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5)", corrected)
     end
 
     def test_autocorrect_only_sample_rate_as_int
       corrected = autocorrect_source("StatsD.increment('foo', 2, 1)")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 1)", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 1)", corrected)
     end
 
     def test_autocorrect_only_tags
       corrected = autocorrect_source("StatsD.increment('foo', 2, nil, ['foo', 'bar'])")
-      assert_equal "StatsD.increment('foo', 2, tags: ['foo', 'bar'])", corrected
+      assert_equal("StatsD.increment('foo', 2, tags: ['foo', 'bar'])", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_array
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, ['foo', 'bar'])")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: ['foo', 'bar'])", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: ['foo', 'bar'])", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_hash_with_curly_braces
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, { foo: 'bar' })")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_hash_without_curly_braces
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, foo: 'bar')")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected)
     end
 
     def test_autocorrect_sample_rate_and_block_pass
       corrected = autocorrect_source("StatsD.distribution('foo', 2, 0.5, &block)")
-      assert_equal "StatsD.distribution('foo', 2, sample_rate: 0.5, &block)", corrected
+      assert_equal("StatsD.distribution('foo', 2, sample_rate: 0.5, &block)", corrected)
     end
 
     def test_autocorrect_sample_rate_tags_and_block_pass
       corrected = autocorrect_source("StatsD.measure('foo', 2, nil, foo: 'bar', &block)")
-      assert_equal "StatsD.measure('foo', 2, tags: { foo: 'bar' }, &block)", corrected
+      assert_equal("StatsD.measure('foo', 2, tags: { foo: 'bar' }, &block)", corrected)
     end
 
     def test_autocorrect_sample_rate_and_curly_braces_block
       corrected = autocorrect_source("StatsD.measure('foo', 2, 0.5) { foo }")
-      assert_equal "StatsD.measure('foo', 2, sample_rate: 0.5) { foo }", corrected
+      assert_equal("StatsD.measure('foo', 2, sample_rate: 0.5) { foo }", corrected)
     end
 
     def test_autocorrect_sample_rate_and_do_end_block
@@ -100,7 +100,7 @@ module Rubocop
           foo
         end
       RUBY
-      assert_equal <<~RUBY, corrected
+      assert_equal(<<~RUBY, corrected)
         StatsD.distribution 'foo', 124, sample_rate: 0.6, tags: ['bar'] do
           foo
         end

data/test/statsd_instrumentation_test.rb

@@ -73,31 +73,31 @@ class StatsDInstrumentationTest < Minitest::Test
   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
       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|
+    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_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
 
@@ -106,11 +106,11 @@ class StatsDInstrumentationTest < Minitest::Test
       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
       ActiveMerchant::Gateway.new.purchase(true)
@@ -122,29 +122,29 @@ class StatsDInstrumentationTest < Minitest::Test
       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|
+    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_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_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
 
@@ -156,17 +156,17 @@ class StatsDInstrumentationTest < Minitest::Test
       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
       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
@@ -192,33 +192,33 @@ class StatsDInstrumentationTest < Minitest::Test
   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_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
       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
       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
@@ -228,43 +228,43 @@ class StatsDInstrumentationTest < Minitest::Test
   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_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
       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
       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
       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
@@ -274,87 +274,99 @@ class StatsDInstrumentationTest < Minitest::Test
   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_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
       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
       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
       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
       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
-    StatsD.prefix = 'Foo'
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
-    StatsD.prefix = 'Quc'
-
-    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, statsd_calls.length
-    assert_equal "Quc.ActiveMerchant.Gateway.sync", statsd_calls.first.name
+    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')
+
+    datagrams = capture_statsd_calls { ActiveMerchant::Gateway.sync }
+    assert_equal(1, datagrams.length)
+    assert_equal("Quc.ActiveMerchant.Gateway.sync", datagrams.first.name)
   ensure
-    StatsD.prefix = nil
-    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+    StatsD.singleton_client = old_client
+    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')
+
+    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')
   end
 
   def test_statsd_macro_can_disable_prefix
-    StatsD.prefix = 'Foo'
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count_success :sync, 'ActiveMerchant.Gateway.sync', no_prefix: true
-    StatsD.prefix = 'Quc'
-
-    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
-    assert_equal 1, statsd_calls.length
-    assert_equal "ActiveMerchant.Gateway.sync.success", statsd_calls.first.name
+    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)
+
+    datagrams = client.capture { ActiveMerchant::Gateway.sync }
+    assert_equal(1, datagrams.length)
+    assert_equal("ActiveMerchant.Gateway.sync.success", datagrams.first.name)
   ensure
-    StatsD.prefix = nil
-    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
       InstrumentedClass.new.send(:public_and_instrumented)
@@ -362,7 +374,7 @@ class StatsDInstrumentationTest < Minitest::Test
   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
       InstrumentedClass.new.send(:protected_and_instrumented)
@@ -370,7 +382,7 @@ class StatsDInstrumentationTest < Minitest::Test
   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
       InstrumentedClass.new.send(:private_and_instrumented)
@@ -378,27 +390,27 @@ class StatsDInstrumentationTest < Minitest::Test
   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
@@ -417,43 +429,6 @@ class StatsDInstrumentationTest < Minitest::Test
     end
   end
 
-  def test_statsd_measure_with_new_client
-    old_client = StatsD.singleton_client
-    StatsD.singleton_client = StatsD::Instrument::Client.new
-
-    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
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-    StatsD.singleton_client = old_client
-  end
-
-  def test_statsd_count_with_new_client
-    old_client = StatsD.singleton_client
-    StatsD.singleton_client = StatsD::Instrument::Client.new
-
-    ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-    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'
-    StatsD.singleton_client = old_client
-  end
-
-  def test_statsd_count_with_injected_client
-    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.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
   private
 
   def assert_scope(klass, method, expected_scope)
@@ -465,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