statsd-instrument 3.9.9 → 3.10.0

data/test/client_test.rb

@@ -8,6 +8,10 @@ class ClientTest < Minitest::Test
     @dogstatsd_client = StatsD::Instrument::Client.new(implementation: "datadog")
   end
 
+  def teardown
+    @client.instance_variable_get(:@aggregator).instance_variable_get(:@flush_thread)&.kill
+  end
+
   def test_client_from_env
     env = StatsD::Instrument::Environment.new(
       "STATSD_ENV" => "production",
@@ -255,11 +259,78 @@ class ClientTest < Minitest::Test
     client = StatsD::Instrument::Client.new(sink: mock_sink, default_sample_rate: 0.5, enable_aggregation: true)
     5.times { client.distribution("metric", 60) }
     client.force_flush
+  end
+
+  def test_increment_with_aggregation_respects_sample_rate
+    # Test that increment with aggregation properly samples before aggregation
+    # and preserves sample_rate in the datagram
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(sink: sink, enable_aggregation: true)
+
+    # With sample_rate=1.0, all increments should be counted
+    client.increment("counter", 1, sample_rate: 1.0)
+    client.increment("counter", 2, sample_rate: 1.0)
+    client.force_flush
+
+    assert_equal(1, sink.datagrams.size)
+    datagram = sink.datagrams.first
+    assert_equal("counter", datagram.name)
+    assert_equal(3, datagram.value)
+    assert_equal(1.0, datagram.sample_rate)
+  end
+
+  def test_increment_with_aggregation_applies_sampling_before_aggregation
+    # Test that sampling happens BEFORE aggregation, not after
+    # This is the key fix - previously sampling was bypassed when aggregation was enabled
+    mock_sink = mock("sink")
+    # First call samples out (false), second call samples in (true)
+    mock_sink.stubs(:sample?).returns(false, true)
+    mock_sink.expects(:<<).with("counter:3|c|@0.5")
+    mock_sink.stubs(:flush)
+
+    client = StatsD::Instrument::Client.new(sink: mock_sink, enable_aggregation: true)
+
+    # First increment should be sampled out
+    client.increment("counter", 5, sample_rate: 0.5)
+    # Second increment should be sampled in
+    client.increment("counter", 3, sample_rate: 0.5)
+    client.force_flush
+  end
+
+  def test_measure_with_aggregation_respects_sample_rate
+    # Test that measure (timing) with aggregation properly handles sample_rate
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(
+      sink: sink,
+      enable_aggregation: true,
+      datagram_builder_class: StatsD::Instrument::StatsDDatagramBuilder,
+    )
+
+    client.measure("timing", 100, sample_rate: 0.5)
+    client.measure("timing", 200, sample_rate: 0.5)
+    client.force_flush
+
+    assert_equal(1, sink.datagrams.size)
+    datagram = sink.datagrams.first
+    assert_equal("timing", datagram.name)
+    assert_equal(0.5, datagram.sample_rate)
+    assert_includes(datagram.source, "|@0.5")
+  end
+
+  def test_histogram_with_aggregation_respects_sample_rate
+    # Test that histogram with aggregation properly handles sample_rate
+    sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    client = StatsD::Instrument::Client.new(sink: sink, enable_aggregation: true)
+
+    client.histogram("hist", 100, sample_rate: 0.25)
+    client.histogram("hist", 200, sample_rate: 0.25)
+    client.force_flush
 
-    # undo mock
-    mock_sink.unstub(:sample?)
-    mock_sink.unstub(:<<)
-    mock_sink.unstub(:flush)
+    assert_equal(1, sink.datagrams.size)
+    datagram = sink.datagrams.first
+    assert_equal("hist", datagram.name)
+    assert_equal(0.25, datagram.sample_rate)
+    assert_includes(datagram.source, "|@0.25")
   end
 
   def test_clone_with_prefix_option

data/test/compiled_metric/counter_test.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CompiledMetricCounterTest < Minitest::Test
+  def setup
+    super
+    @old_client = StatsD.singleton_client
+    @sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    StatsD.singleton_client = StatsD::Instrument::Client.new(
+      sink: @sink,
+      prefix: "test",
+      default_tags: [],
+      enable_aggregation: false,
+    )
+  end
+
+  def teardown
+    super
+    @sink.clear
+    StatsD.singleton_client = @old_client
+  end
+
+  def test_counter_without_define
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter)
+
+    error = assert_raises(ArgumentError) do
+      metric.increment(5)
+    end
+    assert_equal("Every CompiledMetric subclass needs to call `define` before first invocation of increment.", error.message)
+  end
+
+  def test_define_counter_without_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(name: "foo.bar")
+    end
+
+    metric.increment(5)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(5, datagram.value)
+    assert_equal(:c, datagram.type)
+    assert_nil(datagram.tags)
+  end
+
+  def test_define_counter_with_static_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web", env: "prod" },
+      )
+    end
+
+    metric.increment(5)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(5, datagram.value)
+    assert_equal(:c, datagram.type)
+    assert_equal(["env:prod", "service:web"], datagram.tags.sort)
+  end
+
+  def test_define_counter_with_dynamic_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { shop_id: Integer, user_id: Integer },
+      )
+    end
+
+    metric.increment(1, shop_id: 123, user_id: 456)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(1, datagram.value)
+    assert_equal(:c, datagram.type)
+    assert_equal(["shop_id:123", "user_id:456"], datagram.tags.sort)
+  end
+
+  def test_define_counter_with_mixed_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+        tags: { shop_id: Integer },
+      )
+    end
+
+    metric.increment(3, shop_id: 999)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(3, datagram.value)
+    assert_equal(["service:web", "shop_id:999"], datagram.tags.sort)
+  end
+
+  def test_define_counter_with_string_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { country: String, region: String },
+      )
+    end
+
+    metric.increment(2, country: "US", region: "West")
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(2, datagram.value)
+    assert_equal(["country:US", "region:West"], datagram.tags.sort)
+  end
+
+  def test_define_counter_with_float_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { rate: Float },
+      )
+    end
+
+    metric.increment(1, rate: 1.5)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(1, datagram.value)
+    # Float formatting uses %f which outputs full precision
+    assert_equal(1, datagram.tags.size)
+    assert_match(/^rate:1\.5/, datagram.tags.first)
+  end
+
+  def test_define_counter_no_prefix
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        no_prefix: true,
+      )
+    end
+
+    metric.increment(1)
+
+    datagram = @sink.datagrams.first
+    assert_equal("foo.bar", datagram.name) # No "test." prefix
+  end
+
+  def test_multiple_increments_same_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { shop_id: Integer },
+      )
+    end
+
+    metric.increment(1, shop_id: 123)
+    metric.increment(2, shop_id: 123)
+    metric.increment(3, shop_id: 123)
+
+    assert_equal(3, @sink.datagrams.size)
+    @sink.datagrams.each do |datagram|
+      assert_equal(["shop_id:123"], datagram.tags)
+    end
+  end
+
+  def test_multiple_increments_different_tags
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { shop_id: Integer },
+      )
+    end
+
+    metric.increment(1, shop_id: 123)
+    metric.increment(1, shop_id: 456)
+    metric.increment(1, shop_id: 789)
+
+    assert_equal(3, @sink.datagrams.size)
+    assert_equal(["shop_id:123"], @sink.datagrams[0].tags)
+    assert_equal(["shop_id:456"], @sink.datagrams[1].tags)
+    assert_equal(["shop_id:789"], @sink.datagrams[2].tags)
+  end
+
+  def test_counter_includes_default_tags_from_client
+    # Create a client with default tags
+    client = StatsD::Instrument::Client.new(
+      sink: @sink,
+      prefix: "test",
+      default_tags: ["env:production", "region:us-east"],
+      enable_aggregation: false,
+    )
+    StatsD.singleton_client = client
+
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+      )
+    end
+
+    metric.increment(1)
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    # Should include default tags from client + static tags
+    assert_equal(["env:production", "region:us-east", "service:web"], datagram.tags.sort)
+  end
+
+  def test_counter_includes_default_tags_with_no_prefix
+    # Create a client with default tags
+    client = StatsD::Instrument::Client.new(
+      sink: @sink,
+      prefix: "test",
+      default_tags: ["env:production", "region:us-east"],
+      enable_aggregation: false,
+    )
+    StatsD.singleton_client = client
+
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+        no_prefix: true,
+      )
+    end
+
+    metric.increment(1)
+
+    datagram = @sink.datagrams.first
+    assert_equal("foo.bar", datagram.name) # No prefix
+    # Should include default tags even when no_prefix is true
+    assert_equal(["env:production", "region:us-east", "service:web"], datagram.tags.sort)
+  end
+
+  def test_counter_does_not_support_blocks
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+        tags: { shop_id: Integer },
+      )
+    end
+
+    block_called = false
+    metric.increment(shop_id: 999) do
+      block_called = true
+    end
+
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    # Default value
+    assert_equal(1, datagram.value)
+    refute(block_called)
+    assert_equal(["service:web", "shop_id:999"], datagram.tags.sort)
+  end
+end
+
+class CompiledMetricCounterWithAggregationTest < Minitest::Test
+  def setup
+    super
+    @old_client = StatsD.singleton_client
+    @sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
+    @aggregator = StatsD::Instrument::Aggregator.new(
+      @sink,
+      StatsD::Instrument::DatagramBuilder,
+      "test",
+      [],
+      flush_interval: 0.1,
+    )
+    client = StatsD::Instrument::Client.new(
+      sink: @sink,
+      prefix: "test",
+      default_tags: [],
+      enable_aggregation: true,
+    )
+    client.instance_variable_set(:@aggregator, @aggregator)
+    StatsD.singleton_client = client
+  end
+
+  def teardown
+    super
+    @sink.clear
+    StatsD.singleton_client = @old_client
+  end
+
+  def test_aggregates_precompiled_metrics
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { shop_id: Integer },
+      )
+    end
+
+    metric.increment(1, shop_id: 123)
+    metric.increment(2, shop_id: 123)
+    metric.increment(3, shop_id: 123)
+
+    @aggregator.flush
+
+    assert_equal(1, @sink.datagrams.size)
+    datagram = @sink.datagrams.first
+    assert_equal(6, datagram.value) # 1 + 2 + 3
+    assert_equal(["shop_id:123"], datagram.tags)
+  end
+
+  def test_aggregates_different_tag_combinations_separately
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        tags: { shop_id: Integer },
+      )
+    end
+
+    metric.increment(1, shop_id: 123)
+    metric.increment(2, shop_id: 456)
+    metric.increment(3, shop_id: 123)
+
+    @aggregator.flush
+
+    assert_equal(2, @sink.datagrams.size)
+
+    shop_123_datagram = @sink.datagrams.find { |d| d.tags.include?("shop_id:123") }
+    shop_456_datagram = @sink.datagrams.find { |d| d.tags.include?("shop_id:456") }
+
+    assert_equal(4, shop_123_datagram.value) # 1 + 3
+    assert_equal(2, shop_456_datagram.value)
+  end
+
+  def test_aggregates_static_tag_metrics
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+      )
+    end
+
+    metric.increment(1)
+    metric.increment(2)
+    metric.increment(5)
+
+    @aggregator.flush
+
+    assert_equal(1, @sink.datagrams.size)
+    datagram = @sink.datagrams.first
+    assert_equal(8, datagram.value) # 1 + 2 + 5
+  end
+
+  def test_sample_rate_equal_to_1_with_aggregation
+    # When aggregating with sample_rate, sampling happens before aggregation
+    # This test verifies that with sample_rate=1.0, all increments are aggregated
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+        sample_rate: 1.0,
+      )
+    end
+
+    # With sample_rate=1.0, all increments should be aggregated
+    metric.increment(5)
+    metric.increment(3)
+
+    @aggregator.flush
+
+    assert_equal(1, @sink.datagrams.size)
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(8, datagram.value) # 5 + 3
+    # Sample rate should be 1.0 when aggregating
+    assert_equal(1.0, datagram.sample_rate)
+    refute_includes(datagram.source, "|@")
+  end
+
+  def test_sample_rate_applied_with_aggregation
+    # When aggregating with sample_rate, sampling happens before aggregation
+    # This test verifies that with sample_rate=0.5, all increments are aggregated
+    metric = Class.new(StatsD::Instrument::CompiledMetric::Counter) do
+      define(
+        name: "foo.bar",
+        static_tags: { service: "web" },
+        sample_rate: 0.5,
+      )
+    end
+
+    metric.increment(5)
+    metric.increment(3)
+
+    @aggregator.flush
+
+    assert_equal(1, @sink.datagrams.size)
+    datagram = @sink.datagrams.first
+    assert_equal("test.foo.bar", datagram.name)
+    assert_equal(8, datagram.value) # 5 + 3
+    # Sample rate should be 1.0 when aggregating
+    assert_equal(0.5, datagram.sample_rate)
+    assert_includes(datagram.source, "|@")
+  end
+end