statsd-instrument 3.9.3 → 3.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a392592155d75787a30ea7cb16342a84cda2a1c63deb978550f4f9118e997cbb
-  data.tar.gz: 61a5e84e4b025fead6941adef95d7ddd341a97597644719ce74d49ecfba1a595
+  metadata.gz: 8248b85fead25773388f7bec728c5a6347f7b7af61e37e064ee8ed93ba31397d
+  data.tar.gz: 110ab2e5db1b66ef7c76e11ed7b82c925f767df0b09a1ca442afe95c31e30a40
 SHA512:
-  metadata.gz: 7b703ad60f188205c6672498bb0791766e77763c867371025a01c4d4469895e11cc5a9b7ab4180e9db259066125392fe6074bf0cb8836c133a2a7dee8232bf61
-  data.tar.gz: cb9afebc8101618965e419a4ba841863d4c20df54fced19f4d71c726bf168930f74b4b5559538d797f4736a7f02342ded3b51aa7fad1116fe82e2dd78f38e1a2
+  metadata.gz: e85d2333cae7f6e843b25b3a1e64cf8bd1e68e47bcb530b6483dfa05e2672374791209c65f888cc6c9354f0e5bca997098f776c5db10f4dfd155005dd3f22bc9
+  data.tar.gz: 330d5d152a42dd76fae018e4af8c4daa64f9be50391468f64bd338ddd91ecd668a6775f590e45452b552c6fe28f0e82e125a3a91476d5269e52d19ad0adee092

data/.gitignore

@@ -6,3 +6,4 @@ Gemfile.lock
 pkg/*
 vendor/
 tmp/*
+coverage/*

data/CHANGELOG.md

@@ -6,9 +6,14 @@ section below.
 
 ## Unreleased changes
 
+## Version 3.9.4
+
+- [#384](https://github.com/Shopify/statsd-instrument/pull/384) - Aggregation: fixing bug when sending metrics synchronously
+e.g. when the main thread is killed and we are forced to flush the metrics.
+
 ## Version 3.9.3
 
-- [#384](https://github.com/Shopify/statsd-instrument/pull/382) - Fix warnings in Rubocop cops.
+- [#382](https://github.com/Shopify/statsd-instrument/pull/382) - Fix warnings in Rubocop cops.
 
 ## Version 3.9.2
 

data/Gemfile

@@ -12,6 +12,8 @@ gem "rubocop", ">= 1.0"
 gem "rubocop-shopify", require: false
 gem "benchmark-ips"
 gem "dogstatsd-ruby", "~> 5.0", require: false
+gem "simplecov", require: false, group: :test
+
 platform :mri do
   # only if Ruby is MRI && >= 3.2
   if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.2")

data/lib/statsd/instrument/aggregator.rb

@@ -105,17 +105,7 @@ module StatsD
 
         @pid = Process.pid
         @flush_interval = flush_interval
-        @flush_thread = Thread.new do
-          Thread.current.abort_on_exception = true
-          loop do
-            sleep(@flush_interval)
-            thread_healthcheck
-            flush
-          rescue => e
-            StatsD.logger.error { "[#{self.class.name}] Error in flush thread: #{e}" }
-            raise e
-          end
-        end
+        start_flush_thread
 
         ObjectSpace.define_finalizer(
           self,
@@ -131,7 +121,7 @@ module StatsD
       # @return [void]
       def increment(name, value = 1, tags: [], no_prefix: false)
         unless thread_healthcheck
-          sink << datagram_builder(no_prefix: no_prefix).c(name, value, CONST_SAMPLE_RATE, tags)
+          @sink << datagram_builder(no_prefix: no_prefix).c(name, value, CONST_SAMPLE_RATE, tags)
           return
         end
 
@@ -146,8 +136,8 @@ module StatsD
 
       def aggregate_timing(name, value, tags: [], no_prefix: false, type: DISTRIBUTION)
         unless thread_healthcheck
-          sink << datagram_builder(no_prefix: no_prefix).timing_value_packed(
-            name, type, [value], CONST_SAMPLE_RATE, tags
+          @sink << datagram_builder(no_prefix: no_prefix).timing_value_packed(
+            name, type.to_s, [value], CONST_SAMPLE_RATE, tags
           )
           return
         end
@@ -166,7 +156,7 @@ module StatsD
 
       def gauge(name, value, tags: [], no_prefix: false)
         unless thread_healthcheck
-          sink << datagram_builder(no_prefix: no_prefix).g(name, value, CONST_SAMPLE_RATE, tags)
+          @sink << datagram_builder(no_prefix: no_prefix).g(name, value, CONST_SAMPLE_RATE, tags)
           return
         end
 
@@ -240,26 +230,41 @@ module StatsD
         )
       end
 
+      def start_flush_thread
+        @flush_thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          loop do
+            sleep(@flush_interval)
+            thread_healthcheck
+            flush
+          end
+        rescue => e
+          StatsD.logger.error { "[#{self.class.name}] Error in flush thread: #{e}" }
+          raise e
+        end
+      end
+
       def thread_healthcheck
         @mutex.synchronize do
           unless @flush_thread&.alive?
+            # The main thread is dead, fallback to direct writes
             return false unless Thread.main.alive?
 
+            # If the PID changed, the process forked, reset the aggregator state
             if @pid != Process.pid
-              StatsD.logger.debug { "[#{self.class.name}] Restarting the flush thread after fork" }
+              # TODO: Investigate/replace this with Process._fork hook.
+              # https://github.com/ruby/ruby/pull/5017
+              StatsD.logger.debug do
+                "[#{self.class.name}] Restarting the flush thread after fork. State size: #{@aggregation_state.size}"
+              end
               @pid = Process.pid
+              # Clear the aggregation state to avoid duplicate metrics
               @aggregation_state.clear
             else
               StatsD.logger.debug { "[#{self.class.name}] Restarting the flush thread" }
             end
-            @flush_thread = Thread.new do
-              Thread.current.abort_on_exception = true
-              loop do
-                sleep(@flush_interval)
-                thread_healthcheck
-                flush
-              end
-            end
+            # Restart the flush thread
+            start_flush_thread
           end
           true
         end

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.9.3"
+    VERSION = "3.9.4"
   end
 end

data/test/aggregator_test.rb

@@ -1,9 +1,29 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "ostruct"
 
 class AggregatorTest < Minitest::Test
+  class CaptureLogger
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+
+    [:debug, :info, :warn, :error, :fatal].each do |severity|
+      define_method(severity) do |message = nil, &block|
+        message = block.call if message.nil? && block
+        @messages << { severity: severity, message: message }
+      end
+    end
+  end
+
   def setup
+    @logger = CaptureLogger.new
+    @old_logger = StatsD.logger
+    StatsD.logger = @logger
+
     @sink = StatsD::Instrument::CaptureSink.new(parent: StatsD::Instrument::NullSink.new)
     @subject = StatsD::Instrument::Aggregator.new(
       @sink, StatsD::Instrument::DatagramBuilder, nil, [], flush_interval: 0.1
@@ -12,6 +32,7 @@ class AggregatorTest < Minitest::Test
 
   def teardown
     @sink.clear
+    StatsD.logger = @old_logger
   end
 
   def test_increment_simple
@@ -139,4 +160,174 @@ class AggregatorTest < Minitest::Test
     assert_equal("foo", @sink.datagrams.last.name)
     assert_equal(1, @sink.datagrams.last.value)
   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
+    aggregation_state.stubs(:clear).never
+
+    @subject.increment("foo", 1, tags: { foo: "bar" })
+    @subject.aggregate_timing("bar", 100, tags: { foo: "bar" })
+    @subject.gauge("baz", 100, tags: { foo: "bar" })
+
+    # Verify metrics were sent immediately
+    assert_equal(3, @sink.datagrams.size)
+
+    counter_datagram = @sink.datagrams.find { |d| d.name == "foo" }
+    assert_equal(1, counter_datagram.value)
+    assert_equal(["foo:bar"], counter_datagram.tags)
+
+    timing_datagram = @sink.datagrams.find { |d| d.name == "bar" }
+    assert_equal([100.0], [timing_datagram.value])
+    assert_equal(["foo:bar"], timing_datagram.tags)
+
+    gauge_datagram = @sink.datagrams.find { |d| d.name == "baz" }
+    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" })
+
+    # Verify new metrics were also sent immediately
+    assert_equal(5, @sink.datagrams.size)
+
+    counter_datagram = @sink.datagrams.select { |d| d.name == "foo" }.last
+    assert_equal(1, counter_datagram.value)
+    assert_equal(["foo:bar"], counter_datagram.tags)
+
+    timing_datagram = @sink.datagrams.select { |d| d.name == "bar" }.last
+    assert_equal([200.0], [timing_datagram.value])
+    assert_equal(["foo:bar"], timing_datagram.tags)
+
+    # 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" })
+
+    # 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.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.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" })
+
+    # 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" })
+
+      # Simulate thread waiting for flush
+      sleep(0.1)
+      @subject.flush
+
+      assert_equal(2, @sink.datagrams.size)
+      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.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(
+      1,
+      counter_datagrams.size,
+      "Expected to find 1 counter datagram. Datagrams: #{@sink.datagrams.inspect}",
+    )
+    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)
+    assert_equal(1, timing_datagrams.size)
+  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" })
+
+    # Manually trigger the finalizer
+    finalizer = StatsD::Instrument::Aggregator.finalize(
+      @subject.instance_variable_get(:@aggregation_state),
+      @subject.instance_variable_get(:@sink),
+      @subject.instance_variable_get(:@datagram_builders),
+      StatsD::Instrument::DatagramBuilder,
+      [],
+    )
+    finalizer.call
+
+    # Verify that all pending metrics are sent
+    assert_equal(3, @sink.datagrams.size)
+
+    counter_datagram = @sink.datagrams.find { |d| d.name == "foo" }
+    assert_equal(1, counter_datagram.value)
+    assert_equal(["foo:bar"], counter_datagram.tags)
+
+    timing_datagram = @sink.datagrams.find { |d| d.name == "bar" }
+    assert_equal([100.0], [timing_datagram.value])
+    assert_equal(["foo:bar"], timing_datagram.tags)
+
+    gauge_datagram = @sink.datagrams.find { |d| d.name == "baz" }
+    assert_equal(100, gauge_datagram.value)
+    assert_equal(["foo:bar"], gauge_datagram.tags)
+  end
 end

data/test/test_helper.rb

@@ -6,8 +6,9 @@ end
 
 ENV["ENV"] = "test"
 
-unless ENV.key?("CI")
-  require "minitest/pride"
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.start
 end
 require "minitest/autorun"
 unless ENV.key?("CI")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.9.3
+  version: 3.9.4
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-22 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies: []
 description: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
   StatsD instrumentation into your code.