statsd-instrument 3.0.1 → 3.1.2

data/test/null_sink_test.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class NullSinkTest < Minitest::Test
   def test_null_sink
     null_sink = StatsD::Instrument::NullSink.new
-    null_sink << 'foo:1|c' << 'bar:1|c'
+    null_sink << "foo:1|c" << "bar:1|c"
     pass # We don't have anything to assert, except that no exception was raised
   end
 

data/test/rubocop/measure_as_dist_argument_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 MeasureAsDistArgumentTest < Minitest::Test

data/test/rubocop/metaprogramming_positional_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 MetaprogrammingPositionalArgumentsTest < Minitest::Test

data/test/rubocop/metric_prefix_argument_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 MetricPrefixArgumentTest < Minitest::Test

data/test/rubocop/metric_return_value_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 MetricReturnValueTest < Minitest::Test
@@ -12,7 +12,7 @@ module Rubocop
     end
 
     def test_ok_for_non_metric_method
-      assert_no_offenses('backend = StatsD.backend')
+      assert_no_offenses("backend = StatsD.backend")
     end
 
     def test_ok_as_naked_statement

data/test/rubocop/metric_value_keyword_argument_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 MetricValueKeywordArgumentTest < Minitest::Test
@@ -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

@@ -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 PositionalArgumentsTest < Minitest::Test

data/test/rubocop/singleton_configuration_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 SingletonConfigurationTest < Minitest::Test
@@ -13,7 +13,7 @@ module Rubocop
 
     def test_offense_statsd_backend
       assert_offense('StatsD.backend = "foo"')
-      assert_offense('old_backend = StatsD.backend')
+      assert_offense("old_backend = StatsD.backend")
     end
 
     def test_offense_statsd_prefix
@@ -23,21 +23,21 @@ module Rubocop
 
     def test_offense_statsd_default_tags
       assert_offense('StatsD.default_tags = ["foo"]')
-      assert_offense('StatsD.default_tags.empty?')
+      assert_offense("StatsD.default_tags.empty?")
     end
 
     def test_offense_statsd_default_sample_rate
-      assert_offense('StatsD.default_sample_rate = 1.0')
-      assert_offense('should_sample = StatsD.default_sample_rate > rand')
+      assert_offense("StatsD.default_sample_rate = 1.0")
+      assert_offense("should_sample = StatsD.default_sample_rate > rand")
     end
 
     def test_no_offense_for_other_methods
-      assert_no_offenses('StatsD.singleton_client = my_client')
+      assert_no_offenses("StatsD.singleton_client = my_client")
       assert_no_offenses('StatsD.logger.info("foo")')
     end
 
     def test_no_offense_for_constant_reference
-      assert_no_offenses('legacy_client = StatsD')
+      assert_no_offenses("legacy_client = StatsD")
     end
   end
 end

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,191 +184,191 @@ 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.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.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')
+    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')
+    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.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("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')
+    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)
   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_statsd_increment('InstrumentedClass.public_and_instrumented') do
+    assert_statsd_increment("InstrumentedClass.public_and_instrumented") do
       InstrumentedClass.new.send(:public_and_instrumented)
     end
   end
@@ -376,7 +376,7 @@ class StatsDInstrumentationTest < Minitest::Test
   def test_statsd_doesnt_change_method_scope_of_protected_method
     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
@@ -384,33 +384,33 @@ class StatsDInstrumentationTest < Minitest::Test
   def test_statsd_doesnt_change_method_scope_of_private_method
     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')
+    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')
+    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')
+    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