statsd-instrument 3.0.0.pre1 → 3.1.0

data/lib/statsd/instrument/statsd_datagram_builder.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-# @note This class is part of the new Client implementation that is intended
-#   to become the new default in the next major release of this library.
-class StatsD::Instrument::StatsDDatagramBuilder < StatsD::Instrument::DatagramBuilder
-  unsupported_datagram_types :h, :d, :kv
+module StatsD
+  module Instrument
+    # @note This class is part of the new Client implementation that is intended
+    #   to become the new default in the next major release of this library.
+    class StatsDDatagramBuilder < StatsD::Instrument::DatagramBuilder
+      unsupported_datagram_types :h, :d, :kv
 
-  protected
+      protected
 
-  def normalize_tags(tags)
-    raise NotImplementedError, "#{self.class.name} does not support tags" if tags
-    super
+      def normalize_tags(tags)
+        raise NotImplementedError, "#{self.class.name} does not support tags" if tags
+        super
+      end
+    end
   end
 end

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
@@ -79,11 +79,6 @@ module StatsD
         super
       end
 
-      def key_value(*)
-        raise NotImplementedError, "The key_value metric type will be removed " \
-          "from the next major version of statsd-instrument"
-      end
-
       private
 
       def check_block_or_numeric_value(value)

data/lib/statsd/instrument/udp_sink.rb

@@ -1,62 +1,64 @@
 # frozen_string_literal: true
 
-# @note This class is part of the new Client implementation that is intended
-#   to become the new default in the next major release of this library.
-class StatsD::Instrument::UDPSink
-  def self.for_addr(addr)
-    host, port_as_string = addr.split(':', 2)
-    new(host, Integer(port_as_string))
-  end
+module StatsD
+  module Instrument
+    # @note This class is part of the new Client implementation that is intended
+    #   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)
+        new(host, Integer(port_as_string))
+      end
 
-  attr_reader :host, :port
+      attr_reader :host, :port
 
-  def initialize(host, port)
-    @host = host
-    @port = port
-    @mutex = Mutex.new
-    @socket = nil
-  end
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @mutex = Mutex.new
+        @socket = nil
+      end
 
-  def sample?(sample_rate)
-    sample_rate == 1 || rand < sample_rate
-  end
+      def sample?(sample_rate)
+        sample_rate == 1 || rand < sample_rate
+      end
 
-  def <<(datagram)
-    with_socket { |socket| socket.send(datagram, 0) > 0 }
-    self
+      def <<(datagram)
+        with_socket { |socket| socket.send(datagram, 0) }
+        self
 
-  rescue ThreadError
-    # In cases where a TERM or KILL signal has been sent, and we send stats as
-    # part of a signal handler, locks cannot be acquired, so we do our best
-    # to try and send the datagram without a lock.
-    socket.send(datagram, 0) > 0
+      rescue ThreadError
+        # In cases where a TERM or KILL signal has been sent, and we send stats as
+        # part of a signal handler, locks cannot be acquired, so we do our best
+        # to try and send the datagram without a lock.
+        socket.send(datagram, 0) > 0
 
-  rescue SocketError, IOError, SystemCallError
-    # TODO: log?
-    invalidate_socket
-  end
+      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
 
-  private
+      def with_socket
+        @mutex.synchronize { yield(socket) }
+      end
 
-  def with_socket
-    @mutex.synchronize { yield(socket) }
-  end
-
-  def socket
-    if @socket.nil?
-      @socket = UDPSocket.new
-      @socket.connect(@host, @port)
-    end
-    @socket
-  end
+      def socket
+        @socket ||= begin
+          socket = UDPSocket.new
+          socket.connect(@host, @port)
+          socket
+        end
+      end
 
-  def invalidate_socket
-    @mutex.synchronize do
-      @socket = nil
+      def invalidate_socket
+        @mutex.synchronize do
+          @socket = nil
+        end
+      end
     end
   end
 end

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.0.0.pre1"
+    VERSION = "3.1.0"
   end
 end

data/statsd-instrument.gemspec

@@ -16,15 +16,11 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
 
   spec.files = `git ls-files`.split($/)
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'minitest'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'mocha'
-  spec.add_development_dependency 'yard'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'benchmark-ips'
+  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,364 +18,374 @@ 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."
+    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."
+    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."
+    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."
+    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."
+    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', value: 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', value: '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', value: 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)
+    end
   end
 
   def test_assert_statsd_set_call_with_string_value
-    @test_case.assert_statsd_set('set', value: 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', value: '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', value: 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', value: '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', value: '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")
+    end
+
+    @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
 
-    assert_includes assertion.message, "Captured metrics with the same key"
-    assert_includes assertion.message, "MyJob"
+    assert_includes(assertion.message, "Captured metrics with the same key")
+    assert_includes(assertion.message, "MyJob")
   end
 
   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', 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
       end
     end
-    assert_includes assertion.message, "No StatsD calls for metric counter of type c were made"
+    assert_includes(assertion.message, "No StatsD calls for metric counter of type c were made")
   end
 
   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
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
 
     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
     end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
 
     assertion = assert_raises(Minitest::Assertion) do
       @test_case.assert_raises(RuntimeError) do
@@ -384,16 +394,50 @@ class AssertionsTest < Minitest::Test
         end
       end
     end
-    assert_includes assertion.message, "An exception occurred in the block provided to the StatsD assertion"
+    assert_includes(assertion.message, "An exception occurred in the block provided to the StatsD assertion")
   end
 
   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
+    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
 end