statsd-instrument 3.11.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51853f9d4b70fc39649e251e7e93ff3d77b2bcca1d776182f82de8219ea86886
-  data.tar.gz: fce22a816682f0bc25510b6a68248a64c93ba983e7640b57ec01dbb0b985c9d2
+  metadata.gz: 5ba68947d3fa5cec0f604135dbf0fdda92ba4d056262ae2864e3144f8ad395ba
+  data.tar.gz: 63200c83b270a8d840eb88ba3d58a8b615e3f1d4c20aaacb15946ce745f42a90
 SHA512:
-  metadata.gz: 4a06bd60427001260e206243f4db74ecb3d8225c1c5e3f8f9764239bc40901457cf621d7f5fbd0936d39fa0765145499672a9fb0a9c22025ac8611f7051f7154
-  data.tar.gz: f74279e49141844c564d896e1d04b88b6b9f66585e56401a4ee52f7f4cb8dcc5fbe6a99b8427fbfa45ca1be843fef5a8c9357fb629129372880ac5020aceab31
+  metadata.gz: cf8edd51de1582c7b90e9ae07d74277ff093a6ba6d9e896f502bdfab6f94abe1c5d9fb1ed019a8cdf0a700774606595182086dee310659512ac18c17ff8efd16
+  data.tar.gz: de8619df52375bf5aa0a544ee18f5849b892ce82f2ae3ebac77c30ca62c5cb9851ff267aff286e0f8eff2b2ce9f225af925d1d6d8a56cb5a7a8fd4ff9371e744

data/CHANGELOG.md

@@ -6,6 +6,10 @@ section below.
 
 ## Unreleased changes
 
+## Version 4.0.0
+
+- Make the internal aggregator interface positional-only and injectable through `Client`, with fixed-arity `increment`, `gauge`, and `aggregate_timing` entrypoints for native aggregation backends. Public Client metric methods retain their keyword API.
+
 ## Version 3.11.2
 
 - Widen the `CompiledMetric` tag-combination cache key from 32 to 57 bits, eliminating

data/lib/statsd/instrument/aggregator.rb

@@ -148,7 +148,7 @@ module StatsD
       # @param tags [Hash{String, Symbol => String},Array<String>] The tags to attach to the counter.
       # @param no_prefix [Boolean] If true, the metric will not be prefixed.
       # @return [void]
-      def increment(name, value = 1, tags: [], no_prefix: false, sample_rate: CONST_SAMPLE_RATE)
+      def increment(name, value, tags, no_prefix, sample_rate)
         unless thread_healthcheck
           @sink << datagram_builder(no_prefix: no_prefix).c(name, value, sample_rate, tags)
           return
@@ -224,7 +224,7 @@ module StatsD
         end
       end
 
-      def aggregate_timing(name, value, tags: [], no_prefix: false, type: DISTRIBUTION, sample_rate: CONST_SAMPLE_RATE)
+      def aggregate_timing(name, value, tags, no_prefix, type, sample_rate)
         unless thread_healthcheck
           @sink << datagram_builder(no_prefix: no_prefix).timing_value_packed(
             name, type.to_s, [value], sample_rate, tags
@@ -249,7 +249,7 @@ module StatsD
         do_flush(aggregation_state) if aggregation_state
       end
 
-      def gauge(name, value, tags: [], no_prefix: false)
+      def gauge(name, value, tags, no_prefix)
         unless thread_healthcheck
           @sink << datagram_builder(no_prefix: no_prefix).g(name, value, CONST_SAMPLE_RATE, tags)
           return

data/lib/statsd/instrument/client.rb

@@ -19,6 +19,9 @@ module StatsD
     # @see StatsD.singleton_client
     # @see #clone_with_options
     class Client
+      EMPTY_TAGS = [].freeze
+      private_constant :EMPTY_TAGS
+
       class << self
         # Instantiates a StatsD::Instrument::Client using configuration values provided in
         # environment variables.
@@ -31,7 +34,8 @@ module StatsD
           default_tags: env.statsd_default_tags,
           implementation: env.statsd_implementation,
           sink: env.default_sink_for_environment,
-          datagram_builder_class: datagram_builder_class_for_implementation(implementation)
+          datagram_builder_class: datagram_builder_class_for_implementation(implementation),
+          aggregator: nil
         )
           new(
             prefix: prefix,
@@ -42,6 +46,7 @@ module StatsD
             datagram_builder_class: datagram_builder_class,
             enable_aggregation: env.experimental_aggregation_enabled?,
             aggregation_flush_interval: env.aggregation_interval,
+            aggregator: aggregator,
           )
         end
 
@@ -147,6 +152,16 @@ module StatsD
       end
 
       # Instantiates a new client.
+      #
+      # Aggregators use fixed-arity positional +increment+, +gauge+, and
+      # +aggregate_timing+ methods. This keeps the aggregation hot path simple
+      # and avoids keyword argument forwarding. An injected aggregator is also
+      # expected to implement the existing precompiled aggregation methods and
+      # +flush+. Calls without tags receive a shared frozen empty array. Other tag
+      # values are forwarded as-is; custom backends may require arrays.
+      #
+      # @param aggregator [#increment, #gauge, #aggregate_timing, nil]
+      #   Optional external aggregation backend.
       # @see .from_env to instantiate a client using environment variables.
       def initialize(
         prefix: nil,
@@ -157,7 +172,8 @@ module StatsD
         datagram_builder_class: self.class.datagram_builder_class_for_implementation(implementation),
         enable_aggregation: false,
         aggregation_flush_interval: 2.0,
-        aggregation_max_context_size: StatsD::Instrument::Aggregator::DEFAULT_MAX_CONTEXT_SIZE
+        aggregation_max_context_size: StatsD::Instrument::Aggregator::DEFAULT_MAX_CONTEXT_SIZE,
+        aggregator: nil
       )
         @sink = sink
         @datagram_builder_class = datagram_builder_class
@@ -167,10 +183,11 @@ module StatsD
         @default_sample_rate = default_sample_rate
 
         @datagram_builder = { false => nil, true => nil }
-        @enable_aggregation = enable_aggregation
+        @injected_aggregator = aggregator
+        @enable_aggregation = enable_aggregation || !aggregator.nil?
         @aggregation_flush_interval = aggregation_flush_interval
         if @enable_aggregation
-          @aggregator =
+          @aggregator = aggregator ||
             Aggregator.new(
               @sink,
               datagram_builder_class,
@@ -223,7 +240,7 @@ module StatsD
         return StatsD::Instrument::VOID if sample_rate && !sample?(sample_rate)
 
         if @enable_aggregation
-          @aggregator.increment(name, value, tags: tags, no_prefix: no_prefix, sample_rate: sample_rate)
+          @aggregator.increment(name, value, tags || EMPTY_TAGS, no_prefix, sample_rate)
         else
           emit(datagram_builder(no_prefix: no_prefix).c(name, value, sample_rate, tags))
         end
@@ -357,7 +374,7 @@ module StatsD
         end
 
         if @enable_aggregation
-          @aggregator.aggregate_timing(name, value, tags: tags, no_prefix: no_prefix, type: :ms, sample_rate: sample_rate)
+          @aggregator.aggregate_timing(name, value, tags || EMPTY_TAGS, no_prefix, :ms, sample_rate)
           return StatsD::Instrument::VOID
         end
         emit(datagram_builder(no_prefix: no_prefix).ms(name, value, sample_rate, tags))
@@ -379,7 +396,7 @@ module StatsD
       # @return [void]
       def gauge(name, value, sample_rate: nil, tags: nil, no_prefix: false)
         if @enable_aggregation
-          @aggregator.gauge(name, value, tags: tags, no_prefix: no_prefix)
+          @aggregator.gauge(name, value, tags || EMPTY_TAGS, no_prefix)
           return StatsD::Instrument::VOID
         end
 
@@ -431,14 +448,7 @@ module StatsD
         end
 
         if @enable_aggregation
-          @aggregator.aggregate_timing(
-            name,
-            value,
-            tags: tags,
-            no_prefix: no_prefix,
-            type: :d,
-            sample_rate: sample_rate,
-          )
+          @aggregator.aggregate_timing(name, value, tags || EMPTY_TAGS, no_prefix, :d, sample_rate)
           return StatsD::Instrument::VOID
         end
 
@@ -467,7 +477,7 @@ module StatsD
         end
 
         if @enable_aggregation
-          @aggregator.aggregate_timing(name, value, tags: tags, no_prefix: no_prefix, type: :h, sample_rate: sample_rate)
+          @aggregator.aggregate_timing(name, value, tags || EMPTY_TAGS, no_prefix, :h, sample_rate)
           return StatsD::Instrument::VOID
         end
 
@@ -508,10 +518,10 @@ module StatsD
               @aggregator.aggregate_timing(
                 name,
                 latency_in_ms,
-                tags: tags,
-                no_prefix: no_prefix,
-                type: metric_type,
-                sample_rate: sample_rate,
+                tags || EMPTY_TAGS,
+                no_prefix,
+                metric_type,
+                sample_rate,
               )
             else
               emit(datagram_builder(no_prefix: no_prefix).send(metric_type, name, latency_in_ms, sample_rate, tags))
@@ -598,7 +608,8 @@ module StatsD
         prefix: NO_CHANGE,
         default_sample_rate: NO_CHANGE,
         default_tags: NO_CHANGE,
-        datagram_builder_class: NO_CHANGE
+        datagram_builder_class: NO_CHANGE,
+        aggregator: NO_CHANGE
       )
         client = clone_with_options(
           sink: sink,
@@ -606,6 +617,7 @@ module StatsD
           default_sample_rate: default_sample_rate,
           default_tags: default_tags,
           datagram_builder_class: datagram_builder_class,
+          aggregator: aggregator,
         )
 
         yield(client)
@@ -616,7 +628,8 @@ module StatsD
         prefix: NO_CHANGE,
         default_sample_rate: NO_CHANGE,
         default_tags: NO_CHANGE,
-        datagram_builder_class: NO_CHANGE
+        datagram_builder_class: NO_CHANGE,
+        aggregator: NO_CHANGE
       )
         self.class.new(
           sink: sink == NO_CHANGE ? @sink : sink,
@@ -627,6 +640,7 @@ module StatsD
             datagram_builder_class == NO_CHANGE ? @datagram_builder_class : datagram_builder_class,
           enable_aggregation: @enable_aggregation,
           aggregation_flush_interval: @aggregation_flush_interval,
+          aggregator: aggregator == NO_CHANGE ? @injected_aggregator : aggregator,
         )
       end
 

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.11.2"
+    VERSION = "4.0.0"
   end
 end

data/test/aggregator_test.rb

@@ -36,8 +36,8 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_simple
-    @subject.increment("foo", 1, tags: { foo: "bar" })
-    @subject.increment("foo", 1, tags: { foo: "bar" })
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
     @subject.flush
 
     datagram = @sink.datagrams.first
@@ -48,10 +48,9 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_with_sample_rate
-    # Test that increment properly passes through sample_rate
-    @subject.increment("counter.sampled", 1, tags: { foo: "bar" }, sample_rate: 0.5)
-    @subject.increment("counter.sampled", 2, tags: { foo: "bar" }, sample_rate: 0.5)
-    @subject.increment("counter.unsampled", 1, tags: { foo: "bar" })
+    @subject.increment("counter.sampled", 1, ["foo:bar"], false, 0.5)
+    @subject.increment("counter.sampled", 2, ["foo:bar"], false, 0.5)
+    @subject.increment("counter.unsampled", 1, ["foo:bar"], false, 1.0)
     @subject.flush
 
     assert_equal(2, @sink.datagrams.size)
@@ -68,11 +67,10 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_different_sample_rates_create_different_aggregation_keys
-    # Counters with different sample rates should be aggregated separately
-    @subject.increment("counter", 1, sample_rate: 0.5)
-    @subject.increment("counter", 2, sample_rate: 0.5)
-    @subject.increment("counter", 10, sample_rate: 0.1)
-    @subject.increment("counter", 20, sample_rate: 0.1)
+    @subject.increment("counter", 1, [], false, 0.5)
+    @subject.increment("counter", 2, [], false, 0.5)
+    @subject.increment("counter", 10, [], false, 0.1)
+    @subject.increment("counter", 20, [], false, 0.1)
     @subject.flush
 
     assert_equal(2, @sink.datagrams.size)
@@ -85,8 +83,8 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_distribution_simple
-    @subject.aggregate_timing("foo", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("foo", 100, tags: { foo: "bar" })
+    @subject.aggregate_timing("foo", 1, ["foo:bar"], false, :d, 1.0)
+    @subject.aggregate_timing("foo", 100, ["foo:bar"], false, :d, 1.0)
     @subject.flush
 
     datagram = @sink.datagrams.first
@@ -96,9 +94,9 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_timing_sampling_scaling
-    @subject.aggregate_timing("timing.sampled", 60.0, sample_rate: 0.01)
-    @subject.aggregate_timing("timing.sampled", 80.0, sample_rate: 0.01)
-    @subject.aggregate_timing("timing.unsampled", 60.0, sample_rate: 1.0)
+    @subject.aggregate_timing("timing.sampled", 60.0, [], false, :d, 0.01)
+    @subject.aggregate_timing("timing.sampled", 80.0, [], false, :d, 0.01)
+    @subject.aggregate_timing("timing.unsampled", 60.0, [], false, :d, 1.0)
 
     @subject.flush
 
@@ -114,11 +112,11 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_mixed_type_timings
-    @subject.aggregate_timing("foo_ms", 1, tags: { foo: "bar" }, type: :ms)
-    @subject.aggregate_timing("foo_ms", 100, tags: { foo: "bar" }, type: :ms)
+    @subject.aggregate_timing("foo_ms", 1, ["foo:bar"], false, :ms, 1.0)
+    @subject.aggregate_timing("foo_ms", 100, ["foo:bar"], false, :ms, 1.0)
 
-    @subject.aggregate_timing("foo_d", 100, tags: { foo: "bar" }, type: :d)
-    @subject.aggregate_timing("foo_d", 120, tags: { foo: "bar" }, type: :d)
+    @subject.aggregate_timing("foo_d", 100, ["foo:bar"], false, :d, 1.0)
+    @subject.aggregate_timing("foo_d", 120, ["foo:bar"], false, :d, 1.0)
 
     @subject.flush
 
@@ -130,8 +128,8 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_gauge_simple
-    @subject.gauge("foo", 1, tags: { foo: "bar" })
-    @subject.gauge("foo", 100, tags: { foo: "bar" })
+    @subject.gauge("foo", 1, ["foo:bar"], false)
+    @subject.gauge("foo", 100, ["foo:bar"], false)
     @subject.flush
 
     datagram = @sink.datagrams.first
@@ -141,18 +139,18 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_with_tags_in_different_orders
-    @subject.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
-    @subject.increment("foo", 1, tags: ["tag2:val2", "tag1:val1"])
+    @subject.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    @subject.increment("foo", 1, ["tag2:val2", "tag1:val1"], false, 1.0)
     @subject.flush
 
     assert_equal(2, @sink.datagrams.first.value)
   end
 
   def test_increment_with_different_tag_values
-    @subject.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
-    @subject.increment("foo", 1, tags: { tag1: "val1", tag2: "val2" })
+    @subject.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    @subject.increment("foo", 1, { tag1: "val1", tag2: "val2" }, false, 1.0)
 
-    @subject.increment("bar")
+    @subject.increment("bar", 1, [], false, 1.0)
     @subject.flush
 
     assert_equal(2, @sink.datagrams.first.value)
@@ -161,8 +159,8 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_with_different_metric_names
-    @subject.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
-    @subject.increment("bar", 1, tags: ["tag1:val1", "tag2:val2"])
+    @subject.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    @subject.increment("bar", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
     @subject.flush
 
     assert_equal(1, @sink.datagrams.find { |d| d.name == "foo" }.value)
@@ -170,22 +168,22 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_increment_with_different_values
-    @subject.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
-    @subject.increment("foo", 2, tags: ["tag1:val1", "tag2:val2"])
+    @subject.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    @subject.increment("foo", 2, ["tag1:val1", "tag2:val2"], false, 1.0)
     @subject.flush
 
     assert_equal(3, @sink.datagrams.first.value)
   end
 
   def test_send_mixed_types_will_pass_through
-    @subject.increment("test_counter", 1, tags: ["tag1:val1", "tag2:val2"])
-    @subject.aggregate_timing("test_counter", 100, tags: ["tag1:val1", "tag2:val2"])
+    @subject.increment("test_counter", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    @subject.aggregate_timing("test_counter", 100, ["tag1:val1", "tag2:val2"], false, :d, 1.0)
 
-    @subject.gauge("test_gauge", 100, tags: ["tag1:val1", "tag2:val2"])
-    @subject.increment("test_gauge", 1, tags: ["tag1:val1", "tag2:val2"])
+    @subject.gauge("test_gauge", 100, ["tag1:val1", "tag2:val2"], false)
+    @subject.increment("test_gauge", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
 
-    @subject.aggregate_timing("test_timing", 100, tags: ["tag1:val1", "tag2:val2"])
-    @subject.gauge("test_timing", 100, tags: ["tag1:val1", "tag2:val2"])
+    @subject.aggregate_timing("test_timing", 100, ["tag1:val1", "tag2:val2"], false, :d, 1.0)
+    @subject.gauge("test_timing", 100, ["tag1:val1", "tag2:val2"], false)
     @subject.flush
 
     assert_equal(6, @sink.datagrams.size)
@@ -202,10 +200,10 @@ class AggregatorTest < Minitest::Test
   def test_with_prefix
     aggregator = StatsD::Instrument::Aggregator.new(@sink, StatsD::Instrument::DatagramBuilder, "MyApp", [])
 
-    aggregator.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
-    aggregator.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"])
+    aggregator.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
+    aggregator.increment("foo", 1, ["tag1:val1", "tag2:val2"], false, 1.0)
 
-    aggregator.increment("foo", 1, tags: ["tag1:val1", "tag2:val2"], no_prefix: true)
+    aggregator.increment("foo", 1, ["tag1:val1", "tag2:val2"], true, 1.0)
     aggregator.flush
 
     assert_equal(2, @sink.datagrams.size)
@@ -217,14 +215,11 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_finalizer_with_prefix
-    # Test that the finalizer correctly uses the prefix when flushing metrics
-    # IMPORTANT: Use empty tags to ensure datagram_builder is not pre-created by tags_sorted
     aggregator = StatsD::Instrument::Aggregator.new(@sink, StatsD::Instrument::DatagramBuilder, "MyApp", [])
 
-    aggregator.increment("foo", 1, tags: [])
-    aggregator.increment("bar", 1, tags: [], no_prefix: true)
+    aggregator.increment("foo", 1, [], false, 1.0)
+    aggregator.increment("bar", 1, [], true, 1.0)
 
-    # Manually trigger the finalizer (simulates GC cleanup)
     finalizer = StatsD::Instrument::Aggregator.finalize(
       aggregator.instance_variable_get(:@finalizer),
     )
@@ -242,18 +237,15 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_synchronous_operation_on_thread_failure
-    # Force thread_healthcheck to return false
     @subject.stubs(:thread_healthcheck).returns(false)
 
-    # Stub methods on @aggregation_state to ensure they are not called
     aggregation_state = @subject.instance_variable_get(:@aggregation_state)
     aggregation_state.stubs(:[]=).never
 
-    @subject.increment("foo", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("bar", 100, tags: { foo: "bar" })
-    @subject.gauge("baz", 100, tags: { foo: "bar" })
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("bar", 100, ["foo:bar"], false, :d, 1.0)
+    @subject.gauge("baz", 100, ["foo:bar"], false)
 
-    # Verify metrics were sent immediately
     assert_equal(3, @sink.datagrams.size)
 
     counter_datagram = @sink.datagrams.find { |d| d.name == "foo" }
@@ -268,11 +260,9 @@ class AggregatorTest < Minitest::Test
     assert_equal(100, gauge_datagram.value)
     assert_equal(["foo:bar"], gauge_datagram.tags)
 
-    # Additional metrics should also go through synchronously
-    @subject.increment("foo", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("bar", 200, tags: { foo: "bar" }, sample_rate: 0.5)
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("bar", 200, ["foo:bar"], false, :d, 0.5)
 
-    # Verify new metrics were also sent immediately
     assert_equal(5, @sink.datagrams.size)
 
     counter_datagram = @sink.datagrams.select { |d| d.name == "foo" }.last
@@ -287,65 +277,52 @@ class AggregatorTest < Minitest::Test
     after_aggregation_state = @subject.instance_variable_get(:@aggregation_state)
     assert_same(after_aggregation_state, aggregation_state)
 
-    # undo the stubbing
     @subject.unstub(:thread_healthcheck)
   end
 
   def test_recreate_thread_after_fork
     skip("#{RUBY_ENGINE} not supported for this test. Reason: fork()") if RUBY_ENGINE != "ruby"
-    # Record initial metrics
-    @subject.increment("foo", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("bar", 100, tags: { foo: "bar" })
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("bar", 100, ["foo:bar"], false, :d, 1.0)
 
-    # kill the flush thread
     @subject.instance_variable_get(:@flush_thread).kill
 
-    # Fork the process
     pid = Process.fork do
-      # In forked process, send more metrics
-      @subject.increment("foo", 2, tags: { foo: "bar" })
-      @subject.aggregate_timing("bar", 200, tags: { foo: "bar" })
+      @subject.increment("foo", 2, ["foo:bar"], false, 1.0)
+      @subject.aggregate_timing("bar", 200, ["foo:bar"], false, :d, 1.0)
       @subject.flush
 
       assert_equal(2, @sink.datagrams.size)
       exit!
     end
 
-    # Wait for forked process to complete
     Process.wait(pid)
 
-    # Send metrics in parent process
-    @subject.increment("foo", 3, tags: { foo: "bar" })
-    @subject.aggregate_timing("bar", 300, tags: { foo: "bar" })
+    @subject.increment("foo", 3, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("bar", 300, ["foo:bar"], false, :d, 1.0)
     @subject.flush
 
     assert_equal(2, @sink.datagrams.size)
 
-    # Verify metrics were properly aggregated in parent process
     counter_datagrams = @sink.datagrams.select { |d| d.name == "foo" }
     timing_datagrams = @sink.datagrams.select { |d| d.name == "bar" }
 
     assert_equal(1, counter_datagrams.size)
     assert_equal(1, timing_datagrams.size)
 
-    # Aggregate despite fork
     assert_equal(4, counter_datagrams.last.value)
     assert_equal([100.0, 300.0], timing_datagrams.last.value)
   end
 
   def test_race_condition_during_forking
     skip("#{RUBY_ENGINE} not supported for this test. Reason: fork()") if RUBY_ENGINE != "ruby"
-    # Record initial metrics
-    @subject.increment("before_fork.count", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("before_fork.timing", 100, tags: { foo: "bar" })
+    @subject.increment("before_fork.count", 1, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("before_fork.timing", 100, ["foo:bar"], false, :d, 1.0)
 
-    # Fork the process
     pid = Process.fork do
-      # In forked process, send more metrics
-      @subject.increment("in_child.count", 2, tags: { foo: "bar" })
-      @subject.aggregate_timing("in_child.timing", 200, tags: { foo: "bar" })
+      @subject.increment("in_child.count", 2, ["foo:bar"], false, 1.0)
+      @subject.aggregate_timing("in_child.timing", 200, ["foo:bar"], false, :d, 1.0)
 
-      # Simulate thread waiting for flush
       sleep(0.1)
       @subject.flush
 
@@ -353,20 +330,16 @@ class AggregatorTest < Minitest::Test
       exit!
     end
 
-    # Call flush concurrently in parent process
     @subject.flush
 
-    # Wait for forked process to complete
     Process.wait(pid)
 
-    # Send metrics in parent process
-    @subject.increment("after_fork.count", 3, tags: { foo: "bar" })
-    @subject.aggregate_timing("after_fork.timing", 300, tags: { foo: "bar" })
+    @subject.increment("after_fork.count", 3, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("after_fork.timing", 300, ["foo:bar"], false, :d, 1.0)
     @subject.flush
 
     assert_equal(4, @sink.datagrams.size)
 
-    # Verify metrics were properly aggregated in parent process
     counter_datagrams = @sink.datagrams.select { |d| d.name == "before_fork.count" }
     timing_datagrams = @sink.datagrams.select { |d| d.name == "before_fork.count" }
     assert_equal(
@@ -376,7 +349,6 @@ class AggregatorTest < Minitest::Test
     )
     assert_equal(1, timing_datagrams.size)
 
-    # After fork metrics
     counter_datagrams = @sink.datagrams.select { |d| d.name == "after_fork.count" }
     timing_datagrams = @sink.datagrams.select { |d| d.name == "after_fork.count" }
     assert_equal(1, counter_datagrams.size)
@@ -384,18 +356,16 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_finalizer_flushes_pending_metrics
-    @subject.increment("foo", 1, tags: { foo: "bar" })
-    @subject.aggregate_timing("bar", 100, tags: { foo: "bar" })
-    @subject.gauge("baz", 100, tags: { foo: "bar" })
-    @subject.aggregate_timing("sampled_timing", 100, tags: { foo: "bar" }, sample_rate: 0.01)
+    @subject.increment("foo", 1, ["foo:bar"], false, 1.0)
+    @subject.aggregate_timing("bar", 100, ["foo:bar"], false, :d, 1.0)
+    @subject.gauge("baz", 100, ["foo:bar"], false)
+    @subject.aggregate_timing("sampled_timing", 100, ["foo:bar"], false, :d, 0.01)
 
-    # Manually trigger the finalizer
     finalizer = StatsD::Instrument::Aggregator.finalize(
       @subject.instance_variable_get(:@finalizer),
     )
     finalizer.call
 
-    # Verify that all pending metrics are sent
     assert_equal(4, @sink.datagrams.size)
 
     counter_datagram = @sink.datagrams.find { |d| d.name == "foo" }
@@ -418,13 +388,11 @@ class AggregatorTest < Minitest::Test
   def test_aggregator_finalizer_is_called_on_gc
     skip_on_jruby("JRuby's GC does not guarantee finalizers are called promptly")
 
-    5.times { @subject.increment("foo", 1, tags: { foo: "bar" }) }
+    5.times { @subject.increment("foo", 1, ["foo:bar"], false, 1.0) }
 
     @subject.instance_variable_get(:@flush_thread)&.kill
-    # Unbind the aggregator to allow GC to collect it.
     @subject = nil
 
-    # We expect the finalizer to flush the aggregated metrics.
     assert_empty(@sink.datagrams)
 
     5.times do
@@ -441,10 +409,11 @@ class AggregatorTest < Minitest::Test
   end
 
   def test_aggregator_finalizer_is_called_on_gc_after_aggregation_state_move
-    (StatsD::Instrument::Aggregator::DEFAULT_MAX_CONTEXT_SIZE + 5).times { @subject.aggregate_timing("foo", 1) }
+    (StatsD::Instrument::Aggregator::DEFAULT_MAX_CONTEXT_SIZE + 5).times do
+      @subject.aggregate_timing("foo", 1, [], false, :d, 1.0)
+    end
     assert_equal(1, @sink.datagrams.size)
 
-    # Unbind the aggregator to allow GC to collect it.
     @subject = nil
     5.times do
       GC.start(full_mark: true, immediate_mark: true, immediate_sweep: true)
@@ -468,10 +437,9 @@ class AggregatorTest < Minitest::Test
 
     old_trap = Signal.trap("USR1") do
       signal_received = true
-      # These operations should now fall back to direct writes
-      @subject.increment("trap_counter", 1)
-      @subject.gauge("trap_gauge", 42)
-      @subject.aggregate_timing("trap_timing", 100)
+      @subject.increment("trap_counter", 1, [], false, 1.0)
+      @subject.gauge("trap_gauge", 42, [], false)
+      @subject.aggregate_timing("trap_timing", 100, [], false, :d, 1.0)
 
       metrics_sent_in_trap = @sink.datagrams.map(&:name)
     end

data/test/client_test.rb

@@ -102,6 +102,70 @@ class ClientTest < Minitest::Test
     assert_equal(true, !datagram.nil?)
   end
 
+  def test_aggregation_preserves_block_timing_and_return_value
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(sink: sink, enable_aggregation: true)
+    Process.stubs(:clock_gettime).with(Process::CLOCK_MONOTONIC, :float_millisecond).returns(100.0, 125.0)
+
+    result = client.distribution("latency", tags: ["route:cart"]) { :result }
+
+    assert_equal(:result, result)
+    client.force_flush
+    datagram = sink.datagrams.find { |d| d.name == "latency" }
+    assert_equal(25.0, datagram.value)
+  ensure
+    client&.instance_variable_get(:@aggregator)&.instance_variable_get(:@flush_thread)&.kill
+  end
+
+  def test_injected_aggregator_receives_positional_calls
+    aggregator = mock("aggregator")
+    tags = ["route:cart"]
+    aggregator.expects(:increment).with("requests", 2, tags, false, nil)
+    aggregator.expects(:flush)
+
+    client = StatsD::Instrument::Client.new(
+      aggregator: aggregator,
+      sink: StatsD::Instrument::NullSink.new,
+    )
+
+    client.increment("requests", 2, tags: tags)
+    client.force_flush
+  end
+
+  def test_aggregation_supports_existing_compiled_metrics
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(sink: sink, enable_aggregation: true)
+    old_client = StatsD.singleton_client
+    StatsD.singleton_client = client
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(name: "compiled.requests")
+    end
+
+    metric.increment(2)
+    client.force_flush
+
+    datagram = sink.datagrams.find { |d| d.name == "compiled.requests" }
+    assert_equal(2, datagram.value)
+  ensure
+    StatsD.singleton_client = old_client
+    client&.instance_variable_get(:@aggregator)&.instance_variable_get(:@flush_thread)&.kill
+  end
+
+  def test_clone_with_options_preserves_aggregator
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(sink: sink, enable_aggregation: true)
+    clone = client.clone_with_options(prefix: "clone")
+
+    clone.increment("requests")
+    clone.force_flush
+
+    datagram = sink.datagrams.find { |d| d.name == "clone.requests" }
+    assert_equal(1, datagram.value)
+  ensure
+    client&.instance_variable_get(:@aggregator)&.instance_variable_get(:@flush_thread)&.kill
+    clone&.instance_variable_get(:@aggregator)&.instance_variable_get(:@flush_thread)&.kill
+  end
+
   def test_capture
     inner_datagrams = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.11.2
+  version: 4.0.0
 platform: ruby
 authors:
 - Jesse Storimer