statsd-instrument 3.0.1 → 3.1.2

data/lib/statsd/instrument/strict.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'statsd-instrument' unless Object.const_defined?(:StatsD)
+require "statsd-instrument" unless Object.const_defined?(:StatsD)
 
 module StatsD
   module Instrument

data/lib/statsd/instrument/udp_sink.rb

@@ -6,7 +6,7 @@ module StatsD
     #   to become the new default in the next major release of this library.
     class UDPSink
       def self.for_addr(addr)
-        host, port_as_string = addr.split(':', 2)
+        host, port_as_string = addr.split(":", 2)
         new(host, Integer(port_as_string))
       end
 
@@ -20,11 +20,11 @@ module StatsD
       end
 
       def sample?(sample_rate)
-        sample_rate == 1 || rand < sample_rate
+        sample_rate == 1.0 || rand < sample_rate
       end
 
       def <<(datagram)
-        with_socket { |socket| socket.send(datagram, 0) > 0 }
+        with_socket { |socket| socket.send(datagram, 0) }
         self
 
       rescue ThreadError
@@ -33,15 +33,13 @@ module StatsD
         # to try and send the datagram without a lock.
         socket.send(datagram, 0) > 0
 
-      rescue SocketError, IOError, SystemCallError
-        # TODO: log?
+      rescue SocketError, IOError, SystemCallError => error
+        StatsD.logger.debug do
+          "[StatsD::Instrument::UDPSink] Resetting connection because of #{error.class}: #{error.message}"
+        end
         invalidate_socket
       end
 
-      def addr
-        "#{host}:#{port}"
-      end
-
       private
 
       def with_socket
@@ -49,11 +47,11 @@ module StatsD
       end
 
       def socket
-        if @socket.nil?
-          @socket = UDPSocket.new
-          @socket.connect(@host, @port)
+        @socket ||= begin
+          socket = UDPSocket.new
+          socket.connect(@host, @port)
+          socket
         end
-        @socket
       end
 
       def invalidate_socket

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.0.1"
+    VERSION = "3.1.2"
   end
 end

data/lib/statsd/instrument.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'socket'
-require 'logger'
-require 'forwardable'
+require "socket"
+require "logger"
+require "forwardable"
 
 # The `StatsD` module contains low-level metrics for collecting metrics and
 # sending them to the backend.
@@ -31,7 +31,7 @@ module StatsD
     # @private
     # @return [String]
     def self.generate_metric_name(name, callee, *args)
-      name.respond_to?(:call) ? name.call(callee, args).gsub('::', '.') : name.gsub('::', '.')
+      name.respond_to?(:call) ? name.call(callee, args).gsub("::", ".") : name.gsub("::", ".")
     end
 
     # Even though this method is considered private, and is no longer used internally,
@@ -113,26 +113,24 @@ module StatsD
     def statsd_count_success(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
       add_to_method(method, name, :count_success) do
         define_method(method) do |*args, &block|
-          begin
-            truthiness = result = super(*args, &block)
-          rescue
-            truthiness = false
-            raise
-          else
-            if block_given?
-              begin
-                truthiness = yield(result)
-              rescue
-                truthiness = false
-              end
+          truthiness = result = super(*args, &block)
+        rescue
+          truthiness = false
+          raise
+        else
+          if block_given?
+            begin
+              truthiness = yield(result)
+            rescue
+              truthiness = false
             end
-            result
-          ensure
-            client ||= StatsD.singleton_client
-            suffix = truthiness == false ? 'failure' : 'success'
-            key = StatsD::Instrument.generate_metric_name(name, self, *args)
-            client.increment("#{key}.#{suffix}", sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
           end
+          result
+        ensure
+          client ||= StatsD.singleton_client
+          suffix = truthiness == false ? "failure" : "success"
+          key = StatsD::Instrument.generate_metric_name(name, self, *args)
+          client.increment("#{key}.#{suffix}", sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
         end
       end
     end
@@ -152,27 +150,25 @@ module StatsD
     def statsd_count_if(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
       add_to_method(method, name, :count_if) do
         define_method(method) do |*args, &block|
-          begin
-            truthiness = result = super(*args, &block)
-          rescue
-            truthiness = false
-            raise
-          else
-            if block_given?
-              begin
-                truthiness = yield(result)
-              rescue
-                truthiness = false
-              end
-            end
-            result
-          ensure
-            if truthiness
-              client ||= StatsD.singleton_client
-              key = StatsD::Instrument.generate_metric_name(name, self, *args)
-              client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+          truthiness = result = super(*args, &block)
+        rescue
+          truthiness = false
+          raise
+        else
+          if block_given?
+            begin
+              truthiness = yield(result)
+            rescue
+              truthiness = false
             end
           end
+          result
+        ensure
+          if truthiness
+            client ||= StatsD.singleton_client
+            key = StatsD::Instrument.generate_metric_name(name, self, *args)
+            client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+          end
         end
       end
     end
@@ -347,21 +343,22 @@ module StatsD
   end
 end
 
-require 'statsd/instrument/version'
-require 'statsd/instrument/client'
-require 'statsd/instrument/datagram'
-require 'statsd/instrument/dogstatsd_datagram'
-require 'statsd/instrument/datagram_builder'
-require 'statsd/instrument/statsd_datagram_builder'
-require 'statsd/instrument/dogstatsd_datagram_builder'
-require 'statsd/instrument/null_sink'
-require 'statsd/instrument/udp_sink'
-require 'statsd/instrument/capture_sink'
-require 'statsd/instrument/log_sink'
-require 'statsd/instrument/environment'
-require 'statsd/instrument/helpers'
-require 'statsd/instrument/assertions'
-require 'statsd/instrument/expectation'
-require 'statsd/instrument/matchers' if defined?(::RSpec)
-require 'statsd/instrument/railtie' if defined?(::Rails::Railtie)
-require 'statsd/instrument/strict' if ENV['STATSD_STRICT_MODE']
+require "statsd/instrument/version"
+require "statsd/instrument/client"
+require "statsd/instrument/datagram"
+require "statsd/instrument/dogstatsd_datagram"
+require "statsd/instrument/datagram_builder"
+require "statsd/instrument/statsd_datagram_builder"
+require "statsd/instrument/dogstatsd_datagram_builder"
+require "statsd/instrument/null_sink"
+require "statsd/instrument/udp_sink"
+require "statsd/instrument/batched_udp_sink"
+require "statsd/instrument/capture_sink"
+require "statsd/instrument/log_sink"
+require "statsd/instrument/environment"
+require "statsd/instrument/helpers"
+require "statsd/instrument/assertions"
+require "statsd/instrument/expectation"
+require "statsd/instrument/matchers" if defined?(::RSpec)
+require "statsd/instrument/railtie" if defined?(::Rails::Railtie)
+require "statsd/instrument/strict" if ENV["STATSD_STRICT_MODE"]

data/lib/statsd-instrument.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'statsd/instrument'
+require "statsd/instrument"

data/statsd-instrument.gemspec

@@ -21,4 +21,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.metadata['allowed_push_host'] = "https://rubygems.org"
+
+  spec.add_development_dependency 'concurrent-ruby'
 end

data/test/assertions_test.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class AssertionsTest < Minitest::Test
   def setup
     @old_client = StatsD.singleton_client
-    env = StatsD::Instrument::Environment.new('STATSD_IMPLEMENTATION' => 'datadog')
+    env = StatsD::Instrument::Environment.new("STATSD_IMPLEMENTATION" => "datadog")
     StatsD.singleton_client = StatsD::Instrument::Client.from_env(env)
 
     test_class = Class.new(Minitest::Test)
     test_class.send(:include, StatsD::Instrument::Assertions)
-    @test_case = test_class.new('fake')
+    @test_case = test_class.new("fake")
   end
 
   def teardown
@@ -18,187 +18,187 @@ class AssertionsTest < Minitest::Test
   end
 
   def test_assert_no_statsd_calls
-    @test_case.assert_no_statsd_calls('counter') do
+    @test_case.assert_no_statsd_calls("counter") do
       # noop
     end
 
-    @test_case.assert_no_statsd_calls('counter') do
-      StatsD.increment('other')
+    @test_case.assert_no_statsd_calls("counter") do
+      StatsD.increment("other")
     end
 
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls('counter') do
-        StatsD.increment('counter')
+      @test_case.assert_no_statsd_calls("counter") do
+        StatsD.increment("counter")
       end
     end
     assert_equal(assertion.message, "No StatsD calls for metric counter expected.")
 
-    @test_case.assert_no_statsd_calls('counter1', 'counter2') do
+    @test_case.assert_no_statsd_calls("counter1", "counter2") do
       # noop
     end
 
-    @test_case.assert_no_statsd_calls('counter1', 'counter2') do
-      StatsD.increment('counter')
+    @test_case.assert_no_statsd_calls("counter1", "counter2") do
+      StatsD.increment("counter")
     end
 
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls('counter1', 'counter2') do
-        StatsD.increment('counter0')
-        StatsD.increment('counter1')
-        StatsD.increment('counter2')
-        StatsD.increment('counter3')
+      @test_case.assert_no_statsd_calls("counter1", "counter2") do
+        StatsD.increment("counter0")
+        StatsD.increment("counter1")
+        StatsD.increment("counter2")
+        StatsD.increment("counter3")
       end
     end
     assert_equal(assertion.message, "No StatsD calls for metric counter1, counter2 expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_no_statsd_calls('counter0', 'counter1', 'counter2') do
-        StatsD.increment('counter1')
+      @test_case.assert_no_statsd_calls("counter0", "counter1", "counter2") do
+        StatsD.increment("counter1")
       end
     end
     assert_equal(assertion.message, "No StatsD calls for metric counter1 expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_no_statsd_calls do
-        StatsD.increment('other')
+        StatsD.increment("other")
       end
     end
     assert_equal(assertion.message, "No StatsD calls for metric other expected.")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_no_statsd_calls do
-        StatsD.increment('other')
-        StatsD.increment('another')
+        StatsD.increment("other")
+        StatsD.increment("another")
       end
     end
     assert_equal(assertion.message, "No StatsD calls for metric other, another expected.")
   end
 
   def test_assert_statsd
-    @test_case.assert_statsd_increment('counter') do
-      StatsD.increment('counter')
+    @test_case.assert_statsd_increment("counter") do
+      StatsD.increment("counter")
     end
 
-    @test_case.assert_statsd_increment('counter') do
-      StatsD.increment('counter')
-      StatsD.increment('other')
+    @test_case.assert_statsd_increment("counter") do
+      StatsD.increment("counter")
+      StatsD.increment("other")
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('other')
+      @test_case.assert_statsd_increment("counter") do
+        StatsD.increment("other")
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.gauge('counter', 42)
+      @test_case.assert_statsd_increment("counter") do
+        StatsD.gauge("counter", 42)
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('counter')
-        StatsD.increment('counter')
+      @test_case.assert_statsd_increment("counter") do
+        StatsD.increment("counter")
+        StatsD.increment("counter")
       end
     end
 
-    @test_case.assert_statsd_increment('counter', times: 2) do
-      StatsD.increment('counter')
-      StatsD.increment('counter')
+    @test_case.assert_statsd_increment("counter", times: 2) do
+      StatsD.increment("counter")
+      StatsD.increment("counter")
     end
 
-    @test_case.assert_statsd_increment('counter', times: 2, tags: ['foo:1']) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
+    @test_case.assert_statsd_increment("counter", times: 2, tags: ["foo:1"]) do
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 1 })
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', times: 2, tags: ['foo:1']) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
+      @test_case.assert_statsd_increment("counter", times: 2, tags: ["foo:1"]) do
+        StatsD.increment("counter", tags: { foo: 1 })
+        StatsD.increment("counter", tags: { foo: 2 })
       end
     end
 
-    @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
-      StatsD.increment('counter', sample_rate: 0.5, tags: ['a', 'b'])
+    @test_case.assert_statsd_increment("counter", sample_rate: 0.5, tags: ["a", "b"]) do
+      StatsD.increment("counter", sample_rate: 0.5, tags: ["a", "b"])
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
-        StatsD.increment('counter', sample_rate: 0.2, tags: ['c'])
+      @test_case.assert_statsd_increment("counter", sample_rate: 0.5, tags: ["a", "b"]) do
+        StatsD.increment("counter", sample_rate: 0.2, tags: ["c"])
       end
     end
   end
 
   def test_assert_statsd_gauge_call_with_numeric_value
-    @test_case.assert_statsd_gauge('gauge', 42) do
-      StatsD.gauge('gauge', 42)
+    @test_case.assert_statsd_gauge("gauge", 42) do
+      StatsD.gauge("gauge", 42)
     end
 
-    @test_case.assert_statsd_gauge('gauge', '42') do
-      StatsD.gauge('gauge', 42)
+    @test_case.assert_statsd_gauge("gauge", "42") do
+      StatsD.gauge("gauge", 42)
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_gauge('gauge', 42) do
-        StatsD.gauge('gauge', 45)
+      @test_case.assert_statsd_gauge("gauge", 42) do
+        StatsD.gauge("gauge", 45)
       end
     end
 
-    @test_case.assert_statsd_gauge('gauge', value: 42) do
-      StatsD.gauge('gauge', 42)
+    @test_case.assert_statsd_gauge("gauge", value: 42) do
+      StatsD.gauge("gauge", 42)
     end
   end
 
   def test_assert_statsd_set_call_with_string_value
-    @test_case.assert_statsd_set('set', 12345) do
-      StatsD.set('set', '12345')
+    @test_case.assert_statsd_set("set", 12345) do
+      StatsD.set("set", "12345")
     end
 
-    @test_case.assert_statsd_set('set', '12345') do
-      StatsD.set('set', '12345')
+    @test_case.assert_statsd_set("set", "12345") do
+      StatsD.set("set", "12345")
     end
 
-    @test_case.assert_statsd_set('set', 12345) do
-      StatsD.set('set', 12345)
+    @test_case.assert_statsd_set("set", 12345) do
+      StatsD.set("set", 12345)
     end
 
-    @test_case.assert_statsd_set('set', '12345') do
-      StatsD.set('set', 12345)
+    @test_case.assert_statsd_set("set", "12345") do
+      StatsD.set("set", 12345)
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_set('set', '42') do
-        StatsD.set('set', 45)
+      @test_case.assert_statsd_set("set", "42") do
+        StatsD.set("set", 45)
       end
     end
 
-    @test_case.assert_statsd_set('set', value: 12345) do
-      StatsD.set('set', '12345')
+    @test_case.assert_statsd_set("set", value: 12345) do
+      StatsD.set("set", "12345")
     end
 
-    @test_case.assert_statsd_set('set', 'wrong_value', value: 12345) do
-      StatsD.set('set', '12345')
+    @test_case.assert_statsd_set("set", "wrong_value", value: 12345) do
+      StatsD.set("set", "12345")
     end
   end
 
   def test_tags_will_match_subsets
-    @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1 }) do
-      StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2 })
+    @test_case.assert_statsd_increment("counter", sample_rate: 0.5, tags: { a: 1 }) do
+      StatsD.increment("counter", sample_rate: 0.5, tags: { a: 1, b: 2 })
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1, b: 3 }) do
-        StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2, c: 4 })
+      @test_case.assert_statsd_increment("counter", sample_rate: 0.5, tags: { a: 1, b: 3 }) do
+        StatsD.increment("counter", sample_rate: 0.5, tags: { a: 1, b: 2, c: 4 })
       end
     end
   end
 
   def test_tags_friendly_error
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter', tags: { class: "AnotherJob" }) do
-        StatsD.increment('counter', tags: { class: "MyJob" })
+      @test_case.assert_statsd_increment("counter", tags: { class: "AnotherJob" }) do
+        StatsD.increment("counter", tags: { class: "MyJob" })
       end
     end
 
@@ -208,160 +208,158 @@ class AssertionsTest < Minitest::Test
 
   def test_capture_and_assert
     datagrams = @test_case.capture_statsd_datagrams do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
 
-    @test_case.assert_statsd_increment('counter', tags: ['foo:1'], datagrams: datagrams)
-    @test_case.assert_statsd_increment('counter', tags: ['foo:2'], datagrams: datagrams)
+    @test_case.assert_statsd_increment("counter", tags: ["foo:1"], datagrams: datagrams)
+    @test_case.assert_statsd_increment("counter", tags: ["foo:2"], datagrams: datagrams)
   end
 
   def test_capture_from_different_client
     client = StatsD::Instrument::Client.new
-    @test_case.assert_statsd_increment('foo', client: client) do
-      client.increment('foo')
+    @test_case.assert_statsd_increment("foo", client: client) do
+      client.increment("foo")
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('foo', client: client) do
-        StatsD.increment('foo')
+      @test_case.assert_statsd_increment("foo", client: client) do
+        StatsD.increment("foo")
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('foo') do
-        client.increment('foo')
+      @test_case.assert_statsd_increment("foo") do
+        client.increment("foo")
       end
     end
   end
 
   def test_multiple_expectations_are_not_order_dependent
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
 
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
 
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
 
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
 
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_2_metric, foo_1_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
-      StatsD.increment('counter', tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
     end
   end
 
   def test_assert_multiple_statsd_expectations
     assert_raises(Minitest::Assertion) do
-      foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-      foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+      foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+      foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
       @test_case.assert_statsd_expectations([foo_1_metric, foo_2_metric]) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
+        StatsD.increment("counter", tags: { foo: 1 })
+        StatsD.increment("counter", tags: { foo: 2 })
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-      foo_2_metric = StatsD::Instrument::Expectation.increment('counter', tags: ['foo:2'])
+      foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+      foo_2_metric = StatsD::Instrument::Expectation.increment("counter", tags: ["foo:2"])
       @test_case.assert_statsd_expectations([foo_1_metric, foo_2_metric]) do
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 1 })
-        StatsD.increment('counter', tags: { foo: 2 })
-        StatsD.increment('counter', tags: { foo: 2 })
+        StatsD.increment("counter", tags: { foo: 1 })
+        StatsD.increment("counter", tags: { foo: 1 })
+        StatsD.increment("counter", tags: { foo: 2 })
+        StatsD.increment("counter", tags: { foo: 2 })
       end
     end
 
-    foo_1_metric = StatsD::Instrument::Expectation.increment('counter', times: 2, tags: ['foo:1'])
-    foo_2_metric = StatsD::Instrument::Expectation.increment('counter', 1, tags: ['foo:2'])
+    foo_1_metric = StatsD::Instrument::Expectation.increment("counter", times: 2, tags: ["foo:1"])
+    foo_2_metric = StatsD::Instrument::Expectation.increment("counter", 1, tags: ["foo:2"])
     @test_case.assert_statsd_expectations([foo_1_metric, foo_2_metric]) do
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 1 })
-      StatsD.increment('counter', tags: { foo: 2 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 1 })
+      StatsD.increment("counter", tags: { foo: 2 })
     end
   end
 
   def test_assert_statsd_increment_with_tags
-    @test_case.assert_statsd_increment('counter', tags: ['a:b', 'c:d']) do
-      StatsD.increment('counter', tags: { a: 'b', c: 'd' })
+    @test_case.assert_statsd_increment("counter", tags: ["a:b", "c:d"]) do
+      StatsD.increment("counter", tags: { a: "b", c: "d" })
     end
 
-    @test_case.assert_statsd_increment('counter', tags: { a: 'b', c: 'd' }) do
-      StatsD.increment('counter', tags: ['a:b', 'c:d'])
+    @test_case.assert_statsd_increment("counter", tags: { a: "b", c: "d" }) do
+      StatsD.increment("counter", tags: ["a:b", "c:d"])
     end
   end
 
   def test_nested_assertions
-    @test_case.assert_statsd_increment('counter1') do
-      @test_case.assert_statsd_increment('counter2') do
-        StatsD.increment('counter1')
-        StatsD.increment('counter2')
+    @test_case.assert_statsd_increment("counter1") do
+      @test_case.assert_statsd_increment("counter2") do
+        StatsD.increment("counter1")
+        StatsD.increment("counter2")
       end
     end
 
-    @test_case.assert_statsd_increment('counter1') do
-      StatsD.increment('counter1')
-      @test_case.assert_statsd_increment('counter2') do
-        StatsD.increment('counter2')
+    @test_case.assert_statsd_increment("counter1") do
+      StatsD.increment("counter1")
+      @test_case.assert_statsd_increment("counter2") do
+        StatsD.increment("counter2")
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter1') do
-        @test_case.assert_statsd_increment('counter2') do
-          StatsD.increment('counter2')
+      @test_case.assert_statsd_increment("counter1") do
+        @test_case.assert_statsd_increment("counter2") do
+          StatsD.increment("counter2")
         end
       end
     end
 
     assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter1') do
-        @test_case.assert_statsd_increment('counter2') do
-          StatsD.increment('counter1')
+      @test_case.assert_statsd_increment("counter1") do
+        @test_case.assert_statsd_increment("counter2") do
+          StatsD.increment("counter1")
         end
-        StatsD.increment('counter2')
+        StatsD.increment("counter2")
       end
     end
   end
 
   def test_assertion_block_with_expected_exceptions
-    @test_case.assert_statsd_increment('expected_happened') do
+    @test_case.assert_statsd_increment("expected_happened") do
       @test_case.assert_raises(RuntimeError) do
-        begin
-          raise "expected"
-        rescue
-          StatsD.increment('expected_happened')
-          raise
-        end
+        raise "expected"
+      rescue
+        StatsD.increment("expected_happened")
+        raise
       end
     end
 
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
+      @test_case.assert_statsd_increment("counter") do
         @test_case.assert_raises(RuntimeError) do
           raise "expected"
         end
@@ -372,8 +370,8 @@ class AssertionsTest < Minitest::Test
 
   def test_assertion_block_with_unexpected_exceptions
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        StatsD.increment('counter')
+      @test_case.assert_statsd_increment("counter") do
+        StatsD.increment("counter")
         raise "unexpected"
       end
     end
@@ -381,8 +379,8 @@ class AssertionsTest < Minitest::Test
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_raises(RuntimeError) do
-        @test_case.assert_statsd_increment('counter') do
-          StatsD.increment('counter')
+        @test_case.assert_statsd_increment("counter") do
+          StatsD.increment("counter")
           raise "unexpected"
         end
       end
@@ -402,10 +400,57 @@ class AssertionsTest < Minitest::Test
   def test_assertion_block_with_other_assertion_failures
     # If another assertion failure happens inside the block, that failure should have priority
     assertion = assert_raises(Minitest::Assertion) do
-      @test_case.assert_statsd_increment('counter') do
-        @test_case.flunk('other assertion failure')
+      @test_case.assert_statsd_increment("counter") do
+        @test_case.flunk("other assertion failure")
       end
     end
     assert_equal("other assertion failure", assertion.message)
   end
+
+  def test_assert_when_using_no_prefix
+    env = StatsD::Instrument::Environment.new("STATSD_PREFIX" => nil)
+    StatsD.singleton_client = StatsD::Instrument::Client.from_env(env)
+
+    @test_case.assert_statsd_increment("incr", no_prefix: false) do
+      StatsD.increment("incr")
+    end
+
+    @test_case.assert_statsd_increment("incr", no_prefix: true) do
+      StatsD.increment("incr")
+    end
+
+    env = StatsD::Instrument::Environment.new("STATSD_PREFIX" => "prefix")
+    StatsD.singleton_client = StatsD::Instrument::Client.from_env(env)
+
+    @test_case.assert_statsd_increment("incr", no_prefix: false) do
+      StatsD.increment("incr")
+    end
+
+    assert_raises(Minitest::Assertion) do
+      @test_case.assert_statsd_increment("incr", no_prefix: true) do
+        StatsD.increment("incr")
+      end
+    end
+
+    @test_case.assert_statsd_increment("prefix.incr", no_prefix: true) do
+      StatsD.increment("incr")
+    end
+
+    @test_case.assert_statsd_increment("incr", no_prefix: true) do
+      StatsD.increment("incr", no_prefix: true)
+    end
+  end
+
+  def test_client_propagation_to_expectations
+    foo_1_metric = StatsD::Instrument::Expectation.increment("foo")
+    @test_case.assert_statsd_expectations([foo_1_metric]) do
+      StatsD.increment("foo")
+    end
+
+    client = StatsD::Instrument::Client.new(prefix: "prefix")
+    foo_2_metric = StatsD::Instrument::Expectation.increment("foo", client: client)
+    @test_case.assert_statsd_expectations([foo_2_metric]) do
+      StatsD.increment("prefix.foo")
+    end
+  end
 end