statsd-instrument 3.5.5 → 3.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b4caa06189952666d3dd979521ec76bcf4bbf4265605c2d9d30198773f74ab8
-  data.tar.gz: ec65748283c1a32434f6388e24b167133ba53ec36353c4ec5f8ccfe920657b58
+  metadata.gz: 4b7e23789eaa2e8f4589989b748c3bd60b31b6916b58f92a845e96c4876fb6ff
+  data.tar.gz: d19bcff247d6b3dcabbb9142955c8f1781fd54a7b235ffcae41fb59643babbe0
 SHA512:
-  metadata.gz: af4a6f52973f439a4d9246fff0d68c74751173998b1a76c9fdbff87ac001f2718ccc8fe2c5abb6d5bdaa5555f9c82150f196c8fe6f819e913a6828ef269a2e14
-  data.tar.gz: 79f76342bc46cf2d07fd96f1d72bbe5bc2367251ff93b05b6c4ed938fe96d85bf44c8178ca4f1f4a7186f10921bfbaea456b2ce2d32e64db806ec526b2894d71
+  metadata.gz: 3bd9c53e5050773c076b08219965d4c25f509989b3c00ff8fe16c0299e01135b4ca19a02fb7617a5d55737cc776529e865be9f17340f9f8ac406a28562e37f82
+  data.tar.gz: 9a5edafd0f72d4da58ca5ce1783c36755e99d458aff9d338af1abc583e9d23b1ccc825b192ef9f97b5f519b41d576755e3e797892f55483e3154795089618612

data/.github/workflows/tests.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', 'ruby-head', 'jruby-9.3.7.0', 'truffleruby-22.2.0']
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', 'ruby-head', 'jruby-9.3.7.0', 'truffleruby-22.2.0']
         # Windows on macOS builds started failing, so they are disabled for now
         # platform: [windows-2019, macOS-10.14, ubuntu-18.04]
         # exclude:

data/CHANGELOG.md

@@ -6,6 +6,15 @@ section below.
 
 ## Unreleased changes
 
+## Version 3.5.7
+
+- Improve time measurement to avoid seconds to milliseconds conversions.
+
+## Version 3.5.6
+
+- Fix issue from 3.5.5 where tests using RSpec matcher for tag assertion would fail, because the matcher as being
+  use as an array.
+
 ## Version 3.5.5
 
 - Fix issue on 3.5.4, allowing user to specify compound matcher without tags

data/lib/statsd/instrument/assertions.rb

@@ -49,19 +49,41 @@ module StatsD
       # @param [Array<String>] metric_names (default: []) The metric names that are not
       #   allowed to happen inside the block. If this is set to `[]`, the assertion
       #   will fail if any metric occurs.
+      # @param [Array<StatsD::Instrument::Datagram>] datagrams (default: nil) The datagrams
+      #   to be inspected for metric emission.
+      # @param [StatsD::Instrument::Client] client (default: nil) The client to be used
+      #   for fetching datagrams (if not provided) and metric prefix. If not provided, the
+      #   singleton client will attempt to be used.
+      # @param [Boolean] no_prefix (default: false) A directive to indicate if the client's
+      #   prefix should be prepended to the metric names.
       # @yield A block in which the specified metric should not occur. This block
       #   should not raise any exceptions.
       # @return [void]
       # @raise [Minitest::Assertion] If an exception occurs, or if any metric (with the
       #   provided names, or any), occurred during the execution of the provided block.
-      def assert_no_statsd_calls(*metric_names, datagrams: nil, client: nil, &block)
+      def assert_no_statsd_calls(*metric_names, datagrams: nil, client: nil, no_prefix: false, &block)
+        client ||= StatsD.singleton_client
+
         if datagrams.nil?
           raise LocalJumpError, "assert_no_statsd_calls requires a block" unless block_given?
 
           datagrams = capture_statsd_datagrams_with_exception_handling(client: client, &block)
         end
 
-        datagrams.select! { |metric| metric_names.include?(metric.name) } unless metric_names.empty?
+        formatted_metrics = if no_prefix
+          metric_names
+        else
+          metric_names.map do |metric|
+            if StatsD::Instrument::Helpers.prefixed_metric?(metric, client: client)
+              warn("`#{__method__}` will prefix metrics by default. `#{metric}` skipped due to existing prefix.")
+              metric
+            else
+              StatsD::Instrument::Helpers.prefix_metric(metric, client: client)
+            end
+          end
+        end
+
+        datagrams.select! { |metric| formatted_metrics.include?(metric.name) } unless formatted_metrics.empty?
         assert(datagrams.empty?, "No StatsD calls for metric #{datagrams.map(&:name).join(", ")} expected.")
       end
 

data/lib/statsd/instrument/client.rb

@@ -310,16 +310,16 @@ module StatsD
       # @yield The latency (execution time) of the block
       # @return The return value of the provided block will be passed through.
       def latency(name, sample_rate: nil, tags: nil, metric_type: nil, no_prefix: false)
-        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
         begin
           yield
         ensure
-          stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
 
           sample_rate ||= @default_sample_rate
           if sample?(sample_rate)
             metric_type ||= datagram_builder(no_prefix: no_prefix).latency_metric_type
-            latency_in_ms = 1000.0 * (stop - start)
+            latency_in_ms = stop - start
             emit(datagram_builder(no_prefix: no_prefix).send(metric_type, name, latency_in_ms, sample_rate, tags))
           end
         end

data/lib/statsd/instrument/expectation.rb

@@ -37,9 +37,8 @@ module StatsD
       def initialize(client: nil, type:, name:, value: nil,
         sample_rate: nil, tags: nil, no_prefix: false, times: 1)
 
-        client ||= StatsD.singleton_client
         @type = type
-        @name = no_prefix || !client.prefix ? name : "#{client.prefix}.#{name}"
+        @name = no_prefix ? name : StatsD::Instrument::Helpers.prefix_metric(name, client: client)
         @value = normalized_value_for_type(type, value) if value
         @sample_rate = sample_rate
         @tags = normalize_tags(tags)

data/lib/statsd/instrument/helpers.rb

@@ -26,6 +26,18 @@ module StatsD
 
         tags
       end
+
+      def self.prefix_metric(metric_name, client: nil)
+        client ||= StatsD.singleton_client
+        client&.prefix ? "#{client.prefix}.#{metric_name}" : metric_name
+      end
+
+      def self.prefixed_metric?(metric_name, client: nil)
+        client ||= StatsD.singleton_client
+        return false unless client&.prefix
+
+        metric_name =~ /\A#{Regexp.escape(client.prefix)}\./
+      end
     end
   end
 end

data/lib/statsd/instrument/matchers.rb

@@ -45,8 +45,8 @@ module StatsD
           metrics = capture_statsd_calls(&block)
           metrics = metrics.select do |m|
             metric_tags = m.tags || []
-            options_tags = options[:tags] || []
-            tag_matches = options_tags.empty? || metric_tags.all? { |t| options_tags.include?(t) }
+            options_tags = options[:tags]
+            tag_matches = options_tags.nil? || RSpec::Matchers::BuiltIn::Match.new(options_tags).matches?(metric_tags)
             m.type == metric_type && m.name == metric_name && tag_matches
           end
 

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.5.5"
+    VERSION = "3.5.7"
   end
 end

data/test/assertions_test.rb

@@ -74,6 +74,66 @@ class AssertionsTest < Minitest::Test
     assert_equal(assertion.message, "No StatsD calls for metric other, another expected.")
   end
 
+  def test_assert_no_statsd_calls_with_prefix
+    client = StatsD::Instrument::Client.new(prefix: "prefix")
+
+    @test_case.assert_no_statsd_calls("counter", client: client) do
+      client.increment("other")
+    end
+
+    assertion = assert_raises(Minitest::Assertion) do
+      @test_case.assert_no_statsd_calls("counter", client: client) do
+        client.increment("counter")
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric prefix.counter expected.")
+
+    @test_case.expects(:warn).with(
+      "`assert_no_statsd_calls` will prefix metrics by default. `prefix.counter` skipped due to existing prefix."
+    )
+    assertion = assert_raises(Minitest::Assertion) do
+      @test_case.assert_no_statsd_calls("prefix.counter", client: client) do
+        client.increment("counter")
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric prefix.counter expected.")
+
+    @test_case.expects(:warn).never
+    assertion = assert_raises(Minitest::Assertion) do
+      @test_case.assert_no_statsd_calls("prefix.counter", client: client, no_prefix: true) do
+        client.increment("counter")
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric prefix.counter expected.")
+
+    assertion = assert_raises(Minitest::Assertion) do
+      @test_case.assert_no_statsd_calls("counter", client: client, no_prefix: true) do
+        client.increment("counter", no_prefix: true)
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric counter expected.")
+
+    StatsD.singleton_client = client
+
+    @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")
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric prefix.counter expected.")
+
+    assertion = assert_raises(Minitest::Assertion) do
+      @test_case.assert_no_statsd_calls("counter", no_prefix: true) do
+        StatsD.increment("counter", no_prefix: true)
+      end
+    end
+    assert_equal(assertion.message, "No StatsD calls for metric counter expected.")
+  end
+
   def test_assert_statsd
     @test_case.assert_statsd_increment("counter") do
       StatsD.increment("counter")

data/test/client_test.rb

@@ -95,7 +95,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_measure_with_block
-    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC, :float_millisecond).returns(100.0, 200.0)
     datagrams = @client.capture do
       @client.measure("foo") {}
     end
@@ -128,7 +128,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_distribution_with_block
-    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC, :float_millisecond).returns(100.0, 200.0)
     datagrams = @dogstatsd_client.capture do
       @dogstatsd_client.distribution("foo") {}
     end
@@ -137,7 +137,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_latency_emits_ms_metric
-    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC, :float_millisecond).returns(100.0, 200.0)
     datagrams = @client.capture do
       @client.latency("foo") {}
     end
@@ -146,7 +146,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_latency_on_dogstatsd_prefers_distribution_metric_type
-    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC).returns(0.1, 0.2)
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC, :float_millisecond).returns(100.0, 200.0)
     datagrams = @dogstatsd_client.capture do
       @dogstatsd_client.latency("foo") {}
     end

data/test/helpers_test.rb

@@ -7,6 +7,11 @@ class HelpersTest < Minitest::Test
     test_class = Class.new(Minitest::Test)
     test_class.send(:include, StatsD::Instrument::Helpers)
     @test_case = test_class.new("fake")
+    @old_client = StatsD.singleton_client
+  end
+
+  def teardown
+    StatsD.singleton_client = @old_client
   end
 
   def test_capture_metrics_inside_block_only
@@ -78,4 +83,58 @@ class HelpersTest < Minitest::Test
       StatsD::Instrument::Helpers.add_tag(1, :key, 123)
     end
   end
+
+  def test_prefix_metric_returns_metric_if_no_prefix
+    metric = "metric"
+    client = StatsD::Instrument::Client.new(prefix: nil)
+    assert_equal(metric, StatsD::Instrument::Helpers.prefix_metric(metric, client: client))
+  end
+
+  def test_prefix_metric_returns_prefixed_metric
+    prefix = "prefix"
+    metric = "metric"
+    client = StatsD::Instrument::Client.new(prefix: prefix)
+    assert_equal("#{prefix}.#{metric}", StatsD::Instrument::Helpers.prefix_metric(metric, client: client))
+  end
+
+  def test_prefix_metric_can_use_singleton_client
+    prefix = "prefix"
+    metric = "metric"
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: prefix)
+    assert_equal("#{prefix}.#{metric}", StatsD::Instrument::Helpers.prefix_metric(metric))
+  end
+
+  def test_prefixed_metric_return_true_if_prefix_present
+    prefix = "prefix"
+    metric = "prefix.metric"
+    client = StatsD::Instrument::Client.new(prefix: prefix)
+    assert(StatsD::Instrument::Helpers.prefixed_metric?(metric, client: client))
+  end
+
+  def test_prefixed_meric_returns_false_if_prefix_missing
+    prefix = "prefix"
+    metric = "metric"
+    client = StatsD::Instrument::Client.new(prefix: prefix)
+    refute(StatsD::Instrument::Helpers.prefixed_metric?(metric, client: client))
+  end
+
+  def test_prefixed_metric_returns_false_if_prefix_not_at_beginning
+    prefix = "prefix"
+    metric = "metric.prefix"
+    client = StatsD::Instrument::Client.new(prefix: prefix)
+    refute(StatsD::Instrument::Helpers.prefixed_metric?(metric, client: client))
+  end
+
+  def test_prefixed_metrics_returns_false_if_no_prefix_defined
+    metric = "prefix.metric"
+    client = StatsD::Instrument::Client.new(prefix: nil)
+    refute(StatsD::Instrument::Helpers.prefixed_metric?(metric, client: client))
+  end
+
+  def test_prefixed_metric_can_use_singleton_client
+    prefix = "prefix"
+    metric = "prefix.metric"
+    StatsD.singleton_client = StatsD::Instrument::Client.new(prefix: prefix)
+    assert(StatsD::Instrument::Helpers.prefixed_metric?(metric))
+  end
 end

data/test/matchers_test.rb

@@ -2,6 +2,7 @@
 
 require "test_helper"
 require "statsd/instrument/matchers"
+require "rspec/mocks/argument_matchers"
 
 class MatchersTest < Minitest::Test
   def test_statsd_increment_matched
@@ -114,6 +115,13 @@ class MatchersTest < Minitest::Test
       .matches?(lambda { StatsD.increment("counter", tags: ["a", "b"]) }))
   end
 
+  def test_statsd_increment_with_subset_matcher
+    include_matcher = RSpec::Matchers::BuiltIn::Include.new("foo:bar")
+    final = RSpec::Matchers::AliasedMatcher.new(include_matcher, :include)
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: final)
+      .matches?(lambda { StatsD.increment("counter", tags: ["foo:bar", "bar:baz"]) }))
+  end
+
   def test_statsd_increment_with_tags_not_matched
     refute(StatsD::Instrument::Matchers::Increment.new(:c, "counter", tags: ["a", "b"])
       .matches?(lambda { StatsD.increment("counter", tags: ["c"]) }))

data/test/statsd_test.rb

@@ -18,7 +18,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_benchmarked_block_duration
-    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 5000.0 + 1120.0)
     metric = capture_statsd_call do
       StatsD.measure("values.foobar") { "foo" }
     end
@@ -31,7 +31,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_return_in_block_still_captures
-    Process.stubs(:clock_gettime).returns(5.0, 6.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 6120.0)
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
@@ -46,7 +46,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_exception_in_block_still_captures
-    Process.stubs(:clock_gettime).returns(5.0, 6.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 6120.0)
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
@@ -111,7 +111,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_distribution_with_benchmarked_block_duration
-    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 5000.0 + 1120.0)
     metric = capture_statsd_call do
       result = StatsD.distribution("values.foobar") { "foo" }
       assert_equal("foo", result)
@@ -121,7 +121,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_distribution_with_return_in_block_still_captures
-    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 5000.0 + 1120.0)
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
@@ -138,7 +138,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_distribution_with_exception_in_block_still_captures
-    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 5000.0 + 1120.0)
     result = nil
     metric = capture_statsd_call do
       lambda = -> do
@@ -158,7 +158,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_distribution_with_block_and_options
-    Process.stubs(:clock_gettime).returns(5.0, 5.0 + 1.12)
+    Process.stubs(:clock_gettime).returns(5000.0, 5000.0 + 1120.0)
     metric = capture_statsd_call do
       StatsD.distribution("values.foobar", tags: ["test"], sample_rate: 0.9) { "foo" }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.5.5
+  version: 3.5.7
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-04-12 00:00:00.000000000 Z
 dependencies: []
 description: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
   StatsD instrumentation into your code.
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: A StatsD client for Ruby apps