statsd-instrument 3.2.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f42d327300430dd5926c971c7d27d860acd99800cc8eeb4552892f755037553f
-  data.tar.gz: 88c22b7ef591313d0e159a24f3875ddc7a63acf0c6d10551cac6bf069a6c0ad3
+  metadata.gz: bcbaac2cd4178c61bfcb484c45931bb387d81dfa632fbd114bba126c393beb75
+  data.tar.gz: d1101fbc534b6612ff76a282ab45d37aad3a0c185b3ccedf6dcf2ef78ce85bb1
 SHA512:
-  metadata.gz: 8a0d04e0acf3ddb8ae85bb3d5b4a560dbb713c6c8d26654cca6d52b5b3d70a8570b424b489e33d5bcc301f419db8e1de448daaee863fb0624ff52aa10c67c9a4
-  data.tar.gz: f56d3bd3ecd117d9a359de5445f3b00750d11151a40da26f6e902cd1c5800c8688ae1bab05f2457eb519751c642f69278425ba4541a6fe6caa41dd766dd3a21c
+  metadata.gz: 4cd62e31fe1dc59ae49345e598de791ba1295a18d527d88f840de7349d31e8d325cf00543e59eddf02c3fed56a58f9020ace88ca7554de2340d193e8e62cb1d4
+  data.tar.gz: 98fcae4a9b924ab432d745ad2c02f4ac5ed6d0e94ad1f002e80afc0f4f741f01412dbf605151813432dc828ad57f9c1747e26a7127c32950df9ffddeb90e9523

data/.github/workflows/benchmark.yml

@@ -13,12 +13,15 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6
+        ruby-version: 3.1
         bundler-cache: true
 
     - name: Run benchmark on branch
       run: benchmark/send-metrics-to-local-udp-receiver
 
+    - name: Run throughput benchmark on branch
+      run: benchmark/local-udp-throughput
+
     - uses: actions/checkout@v1
       with:
         ref: 'master'
@@ -28,3 +31,6 @@ jobs:
 
     - name: Run benchmark on master
       run: benchmark/send-metrics-to-local-udp-receiver
+
+    - name: Run throughput benchmark on master
+      run: benchmark/local-udp-throughput

data/.github/workflows/cla.yml

@@ -0,0 +1,22 @@
+name: Contributor License Agreement (CLA)
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+  issue_comment:
+    types: [created]
+
+jobs:
+  cla:
+    runs-on: ubuntu-latest
+    if: |
+      (github.event.issue.pull_request 
+        && !github.event.issue.pull_request.merged_at
+        && contains(github.event.comment.body, 'signed')
+      ) 
+      || (github.event.pull_request && !github.event.pull_request.merged)
+    steps:
+      - uses: Shopify/shopify-cla-action@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cla-token: ${{ secrets.CLA_TOKEN }}

data/.github/workflows/tests.yml

@@ -9,9 +9,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1']
-
-        # Windows on macOS builds started failing, so they are disabled for noew
+        ruby: ['2.6', '2.7', '3.0', '3.1', '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/.rubocop.yml

@@ -17,6 +17,18 @@ Naming/FileName:
   Exclude:
     - lib/statsd-instrument.rb
 
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Style/WhileUntilModifier:
+  Enabled: false
+
+Style/IdenticalConditionalBranches:
+  Enabled: false
+
 # Enable our own cops on our own repo
 
 StatsD/MetricReturnValue:

data/CHANGELOG.md

@@ -6,7 +6,25 @@ section below.
 
 ### Unreleased changes
 
-_Nothing yet_
+- UDP Batching has been largely refactored again. The `STATSD_FLUSH_INTERVAL` environment variable
+  is deprecated. It still disable batching if set to `0`, but other than that is has no effect.
+  Setting `STATSD_BUFFER_CAPACITY` to `0` is now the recommended way to disable batching.
+- The synchronous UDP sink now use one socket per thread, instead of a single socket
+  protected by a mutex.
+
+## Version 3.3.0
+
+- UDP Batching now has a max queue size and emitter threads will block if the queue
+  reaches the limit. This is to prevent the queue from growing unbounded.
+  More generally the UDP batching mode was optimized to improve throughput and to
+  flush the queue more eagerly (#309).
+- Added `STATSD_BUFFER_CAPACITY` configuration.
+- Added `STATSD_MAX_PACKET_SIZE` configuration.
+- Require `set` explicitly, to avoid breaking tests for users of this library (#311)
+
+## Version 3.2.1
+
+- Fix a bug in UDP batching that could cause the Ruby process to be stuck on exit (#291).
 
 ## Version 3.2.0
 

data/README.md

@@ -42,9 +42,18 @@ The following environment variables are supported:
   overridden in a metric method call.
 - `STATSD_DEFAULT_TAGS`: A comma-separated list of tags to apply to all metrics.
   (Note: tags are not supported by all implementations.)
-- `STATSD_FLUSH_INTERVAL`: (default: `1.0`) The interval in seconds at which
-  events are sent in batch. Only applicable to the UDP configuration. If set
-  to `0.0`, metrics are sent immediately.
+- `STATSD_BUFFER_CAPACITY`: (default: `5000`) The maximum amount of events that
+  may be buffered before emitting threads will start to block. Increasing this
+  value may help for application generating spikes of events. However if the
+  application emit events faster than they can be sent, increasing it won't help.
+  If set to `0`, batching will be disabled, and events will be sent in individual
+  UDP packets, which is much slower.
+- `STATSD_FLUSH_INTERVAL`: (default: `1`) Deprecated. Setting this to `0` is
+  equivalent to setting `STATSD_BUFFER_CAPACITY` to `0`.
+- `STATSD_MAX_PACKET_SIZE`: (default: `1472`) The maximum size of UDP packets.
+  If your network is properly configured to handle larger packets you may try
+  to increase this value for better performance, but most network can't handle
+  larger packets.
 
 ## StatsD keys
 

data/benchmark/local-udp-throughput

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "benchmark/ips"
+require "tmpdir"
+require "socket"
+require "statsd-instrument"
+
+def send_metrics(client)
+  client.increment("StatsD.increment", 10)
+  client.measure("StatsD.measure") { 1 + 1 }
+  client.gauge("StatsD.gauge", 12.0, tags: ["foo:bar", "quc"])
+  client.set("StatsD.set", "value", tags: { foo: "bar", baz: "quc" })
+  client.event("StasD.event", "12345")
+  client.service_check("StatsD.service_check", "ok")
+end
+
+THREAD_COUNT = Integer(ENV.fetch("THREAD_COUNT", 5))
+EVENTS_PER_ITERATION = 6
+ITERATIONS = 50_000
+def benchmark_implementation(name, env = {})
+  intermediate_results_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/"
+  log_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_NAME)}-#{name}.log"
+  FileUtils.mkdir_p(File.dirname(intermediate_results_filename))
+
+  # Set up an UDP listener to which we can send StatsD packets
+  receiver = UDPSocket.new
+  receiver.bind("localhost", 0)
+
+  log_file = File.open(log_filename, "w+", level: Logger::WARN)
+  StatsD.logger = Logger.new(log_file)
+
+  udp_client = StatsD::Instrument::Environment.new(ENV.to_h.merge(
+    "STATSD_ADDR" => "#{receiver.addr[2]}:#{receiver.addr[1]}",
+    "STATSD_IMPLEMENTATION" => "dogstatsd",
+    "STATSD_ENV" => "production",
+  ).merge(env)).client
+
+  puts "===== #{name} throughtput (#{THREAD_COUNT} threads) ====="
+  threads = THREAD_COUNT.times.map do
+    Thread.new do
+      count = ITERATIONS
+      while (count -= 1) > 0
+        send_metrics(udp_client)
+      end
+    end
+  end
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  threads.each(&:join)
+  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+  events_sent = THREAD_COUNT * EVENTS_PER_ITERATION * ITERATIONS
+  puts "events: #{(events_sent / duration).round(1)}/s"
+  receiver.close
+  udp_client.shutdown if udp_client.respond_to?(:shutdown)
+end
+
+benchmark_implementation("UDP sync", "STATSD_BUFFER_CAPACITY" => "0")
+benchmark_implementation("UDP batched")

data/benchmark/send-metrics-to-local-udp-receiver

@@ -7,53 +7,77 @@ require "tmpdir"
 require "socket"
 require "statsd-instrument"
 
-revision = %x(git rev-parse HEAD).rstrip
-base_revision = %x(git rev-parse origin/master).rstrip
-branch = if revision == base_revision
-  "master"
-else
-  %x(git rev-parse --abbrev-ref HEAD).rstrip
+def send_metrics(client)
+  client.increment("StatsD.increment", 10)
+  client.measure("StatsD.measure") { 1 + 1 }
+  client.gauge("StatsD.gauge", 12.0, tags: ["foo:bar", "quc"])
+  client.set("StatsD.set", "value", tags: { foo: "bar", baz: "quc" })
+  if client.datagram_builder_class == StatsD::Instrument::DogStatsDDatagramBuilder
+    client.event("StasD.event", "12345")
+    client.service_check("StatsD.service_check", "ok")
+  end
 end
 
-intermediate_results_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_NAME)}"
-FileUtils.mkdir_p(File.dirname(intermediate_results_filename))
-
-# Set up an UDP listener to which we can send StatsD packets
-receiver = UDPSocket.new
-receiver.bind("localhost", 0)
-
-StatsD.singleton_client = StatsD::Instrument::Environment.new(
-  "STATSD_ADDR" => "#{receiver.addr[2]}:#{receiver.addr[1]}",
-  "STATSD_IMPLEMENTATION" => "dogstatsd",
-  "STATSD_ENV" => "production",
-).client
-
-report = Benchmark.ips do |bench|
-  bench.report("StatsD metrics to local UDP receiver (branch: #{branch}, sha: #{revision[0, 7]})") do
-    StatsD.increment("StatsD.increment", 10)
-    StatsD.measure("StatsD.measure") { 1 + 1 }
-    StatsD.gauge("StatsD.gauge", 12.0, tags: ["foo:bar", "quc"])
-    StatsD.set("StatsD.set", "value", tags: { foo: "bar", baz: "quc" })
-    if StatsD.singleton_client.datagram_builder_class == StatsD::Instrument::DogStatsDDatagramBuilder
-      StatsD.event("StasD.event", "12345")
-      StatsD.service_check("StatsD.service_check", "ok")
+def benchmark_implementation(name, env = {})
+  revision = %x(git rev-parse HEAD).rstrip
+  base_revision = %x(git rev-parse origin/master).rstrip
+  branch = if revision == base_revision
+    "master"
+  else
+    %x(git rev-parse --abbrev-ref HEAD).rstrip
+  end
+
+  intermediate_results_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_NAME)}-#{name}"
+  log_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_NAME)}-#{name}.log"
+  FileUtils.mkdir_p(File.dirname(intermediate_results_filename))
+
+  # Set up an UDP listener to which we can send StatsD packets
+  receiver = UDPSocket.new
+  receiver.bind("localhost", 0)
+
+  log_file = File.open(log_filename, "w+", level: Logger::WARN)
+  StatsD.logger = Logger.new(log_file)
+
+  udp_client = StatsD::Instrument::Environment.new(ENV.to_h.merge(
+    "STATSD_ADDR" => "#{receiver.addr[2]}:#{receiver.addr[1]}",
+    "STATSD_IMPLEMENTATION" => "dogstatsd",
+    "STATSD_ENV" => "production",
+  ).merge(env)).client
+
+  puts "===== #{name} ====="
+  report = Benchmark.ips do |bench|
+    bench.report("#{name} (branch: #{branch}, sha: #{revision[0, 7]})") do
+      send_metrics(udp_client)
     end
+
+    # Store the results in between runs
+    bench.save!(intermediate_results_filename)
+    bench.compare!
   end
 
-  # Store the results in between runs
-  bench.save!(intermediate_results_filename)
-  bench.compare!
-end
+  receiver.close
+  udp_client.shutdown if udp_client.respond_to?(:shutdown)
+
+  if report.entries.length == 1
+    puts
+    puts "To compare the performance of this revision against another revision (e.g. master),"
+    puts "check out a different branch and run this benchmark script again."
+  elsif ENV["KEEP_RESULTS"]
+    puts
+    puts "The intermediate results have been stored in #{intermediate_results_filename}"
+  else
+    File.unlink(intermediate_results_filename)
+  end
 
-receiver.close
-
-if report.entries.length == 1
-  puts
-  puts "To compare the performance of this revision against another revision (e.g. master),"
-  puts "check out a different branch and run this benchmark script again."
-elsif ENV["KEEP_RESULTS"]
-  puts
-  puts "The intermediate results have been stored in #{intermediate_results_filename}"
-else
-  File.unlink(intermediate_results_filename)
+  log_file.close
+  logs = File.read(log_filename)
+  unless logs.empty?
+    puts
+    puts "==== logs ===="
+    puts logs
+  end
+  puts "================"
 end
+
+benchmark_implementation("UDP sync", "STATSD_BUFFER_CAPACITY" => "0")
+benchmark_implementation("UDP batched")

data/lib/statsd/instrument/batched_udp_sink.rb

@@ -5,12 +5,14 @@ module StatsD
     # @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 BatchedUDPSink
-      DEFAULT_FLUSH_INTERVAL = 1.0
-      MAX_PACKET_SIZE = 508
+      DEFAULT_THREAD_PRIORITY = 100
+      DEFAULT_BUFFER_CAPACITY = 5_000
+      # https://docs.datadoghq.com/developers/dogstatsd/high_throughput/?code-lang=ruby#ensure-proper-packet-sizes
+      DEFAULT_MAX_PACKET_SIZE = 1472
 
-      def self.for_addr(addr, flush_interval: DEFAULT_FLUSH_INTERVAL)
+      def self.for_addr(addr, **kwargs)
         host, port_as_string = addr.split(":", 2)
-        new(host, Integer(port_as_string), flush_interval: flush_interval)
+        new(host, Integer(port_as_string), **kwargs)
       end
 
       attr_reader :host, :port
@@ -21,10 +23,22 @@ module StatsD
         end
       end
 
-      def initialize(host, port, flush_interval: DEFAULT_FLUSH_INTERVAL)
+      def initialize(
+        host,
+        port,
+        thread_priority: DEFAULT_THREAD_PRIORITY,
+        buffer_capacity: DEFAULT_BUFFER_CAPACITY,
+        max_packet_size: DEFAULT_MAX_PACKET_SIZE
+      )
         @host = host
         @port = port
-        @dispatcher = Dispatcher.new(host, port, flush_interval)
+        @dispatcher = Dispatcher.new(
+          host,
+          port,
+          buffer_capacity,
+          thread_priority,
+          max_packet_size,
+        )
         ObjectSpace.define_finalizer(self, self.class.finalize(@dispatcher))
       end
 
@@ -37,83 +51,125 @@ module StatsD
         self
       end
 
-      class Dispatcher
-        BUFFER_CLASS = if !::Object.const_defined?(:RUBY_ENGINE) || RUBY_ENGINE == "ruby"
-          ::Array
-        else
-          begin
-            gem("concurrent-ruby")
-          rescue Gem::MissingSpecError
-            raise Gem::MissingSpecError, "statsd-instrument depends on `concurrent-ruby` on #{RUBY_ENGINE}"
-          end
-          require "concurrent/array"
-          Concurrent::Array
+      def shutdown(*args)
+        @dispatcher.shutdown(*args)
+      end
+
+      class Buffer < SizedQueue
+        def push_nonblock(item)
+          push(item, true)
+        rescue ThreadError, ClosedQueueError
+          nil
         end
 
-        def initialize(host, port, flush_interval)
-          @host = host
-          @port = port
+        def inspect
+          "<#{self.class.name}:#{object_id} capacity=#{max} size=#{size}>"
+        end
+
+        def pop_nonblock
+          pop(true)
+        rescue ThreadError
+          nil
+        end
+      end
+
+      class Dispatcher
+        def initialize(host, port, buffer_capacity, thread_priority, max_packet_size)
+          @udp_sink = UDPSink.new(host, port)
           @interrupted = false
-          @flush_interval = flush_interval
-          @buffer = BUFFER_CLASS.new
+          @thread_priority = thread_priority
+          @max_packet_size = max_packet_size
+          @buffer_capacity = buffer_capacity
+          @buffer = Buffer.new(buffer_capacity)
           @dispatcher_thread = Thread.new { dispatch }
+          @pid = Process.pid
         end
 
         def <<(datagram)
-          unless @dispatcher_thread&.alive?
-            # If the dispatcher thread is dead, we assume it is because
-            # the process was forked. So to avoid ending datagrams twice
-            # we clear the buffer.
-            @buffer.clear
-            @dispatcher_thread = Thread.new { dispatch }
+          if !thread_healthcheck || !@buffer.push_nonblock(datagram)
+            # The buffer is full or the thread can't be respaned,
+            # we'll send the datagram synchronously
+            @udp_sink << datagram
           end
-          @buffer << datagram
+
           self
         end
 
-        def shutdown(wait = @flush_interval * 2)
+        def shutdown(wait = 2)
           @interrupted = true
+          @buffer.close
           if @dispatcher_thread&.alive?
             @dispatcher_thread.join(wait)
-          else
-            flush
           end
+          flush(blocking: false)
         end
 
         private
 
         NEWLINE = "\n".b.freeze
-        def flush
-          return if @buffer.empty?
 
-          datagrams = @buffer.shift(@buffer.size)
-
-          until datagrams.empty?
-            packet = String.new(datagrams.pop, encoding: Encoding::BINARY, capacity: MAX_PACKET_SIZE)
+        def flush(blocking:)
+          packet = "".b
+          next_datagram = nil
+          until @buffer.closed? && @buffer.empty? && next_datagram.nil?
+            if blocking
+              next_datagram ||= @buffer.pop
+              break if next_datagram.nil? # queue was closed
+            else
+              next_datagram ||= @buffer.pop_nonblock
+              break if next_datagram.nil? # no datagram in buffer
+            end
 
-            until datagrams.empty? || packet.bytesize + datagrams.first.bytesize + 1 > MAX_PACKET_SIZE
-              packet << NEWLINE << datagrams.shift
+            packet << next_datagram
+            next_datagram = nil
+            unless packet.bytesize > @max_packet_size
+              while (next_datagram = @buffer.pop_nonblock)
+                if @max_packet_size - packet.bytesize - 1 > next_datagram.bytesize
+                  packet << NEWLINE << next_datagram
+                else
+                  break
+                end
+              end
             end
 
-            send_packet(packet)
+            @udp_sink << packet
+            packet.clear
+          end
+        end
+
+        def thread_healthcheck
+          # TODO: We have a race condition on JRuby / Truffle here. It could cause multiple
+          # dispatcher threads to be spawned, which would cause problems.
+          # However we can't simply lock here as we might be called from a trap context.
+          unless @dispatcher_thread&.alive?
+            # If the main the main thread is dead the VM is shutting down so we won't be able
+            # to spawn a new thread, so we fallback to sending our datagram directly.
+            return false unless Thread.main.alive?
+
+            # If the dispatcher thread is dead, it might be because the process was forked.
+            # So to avoid sending datagrams twice we clear the buffer.
+            if @pid != Process.pid
+              StatsD.logger.info { "[#{self.class.name}] Restarting the dispatcher thread after fork" }
+              @pid = Process.pid
+              @buffer.clear
+            else
+              StatsD.logger.info { "[#{self.class.name}] Restarting the dispatcher thread" }
+            end
+            @dispatcher_thread = Thread.new { dispatch }.tap { |t| t.priority = @thread_priority }
           end
+          true
         end
 
         def dispatch
           until @interrupted
             begin
-              start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              flush
-              next_sleep_duration = @flush_interval - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start)
-
-              sleep(next_sleep_duration) if next_sleep_duration > 0
+              flush(blocking: true)
             rescue => error
               report_error(error)
             end
           end
 
-          flush
-          invalidate_socket
+          flush(blocking: false)
         end
 
         def report_error(error)
@@ -121,38 +177,6 @@ module StatsD
             "[#{self.class.name}] The dispatcher thread encountered an error #{error.class}: #{error.message}"
           end
         end
-
-        def send_packet(packet)
-          retried = false
-          socket.send(packet, 0)
-        rescue SocketError, IOError, SystemCallError => error
-          StatsD.logger.debug do
-            "[#{self.class.name}] Resetting connection because of #{error.class}: #{error.message}"
-          end
-          invalidate_socket
-          if retried
-            StatsD.logger.warning do
-              "[#{self.class.name}] Events were dropped because of #{error.class}: #{error.message}"
-            end
-          else
-            retried = true
-            retry
-          end
-        end
-
-        def socket
-          @socket ||= begin
-            socket = UDPSocket.new
-            socket.connect(@host, @port)
-            socket
-          end
-        end
-
-        def invalidate_socket
-          @socket&.close
-        ensure
-          @socket = nil
-        end
       end
     end
   end

data/lib/statsd/instrument/environment.rb

@@ -35,6 +35,14 @@ module StatsD
 
       def initialize(env)
         @env = env
+        if env.key?("STATSD_FLUSH_INTERVAL")
+          value = env["STATSD_FLUSH_INTERVAL"]
+          if Float(value) == 0.0
+            warn("STATSD_FLUSH_INTERVAL=#{value} is deprecated, please set STATSD_BUFFER_CAPACITY=0 instead.")
+          else
+            warn("STATSD_FLUSH_INTERVAL=#{value} is deprecated and has no effect, please remove it.")
+          end
+        end
       end
 
       # Detects the current environment, either by asking Rails, or by inspecting environment variables.
@@ -78,8 +86,16 @@ module StatsD
         env.key?("STATSD_DEFAULT_TAGS") ? env.fetch("STATSD_DEFAULT_TAGS").split(",") : nil
       end
 
-      def statsd_flush_interval
-        Float(env.fetch("STATSD_FLUSH_INTERVAL", 1.0))
+      def statsd_buffer_capacity
+        Integer(env.fetch("STATSD_BUFFER_CAPACITY", StatsD::Instrument::BatchedUDPSink::DEFAULT_BUFFER_CAPACITY))
+      end
+
+      def statsd_batching?
+        statsd_buffer_capacity > 0 && Float(env.fetch("STATSD_FLUSH_INTERVAL", 1.0)) > 0.0
+      end
+
+      def statsd_max_packet_size
+        Float(env.fetch("STATSD_MAX_PACKET_SIZE", StatsD::Instrument::BatchedUDPSink::DEFAULT_MAX_PACKET_SIZE))
       end
 
       def client
@@ -89,8 +105,12 @@ module StatsD
       def default_sink_for_environment
         case environment
         when "production", "staging"
-          if statsd_flush_interval > 0.0
-            StatsD::Instrument::BatchedUDPSink.for_addr(statsd_addr, flush_interval: statsd_flush_interval)
+          if statsd_batching?
+            StatsD::Instrument::BatchedUDPSink.for_addr(
+              statsd_addr,
+              buffer_capacity: statsd_buffer_capacity,
+              max_packet_size: statsd_max_packet_size,
+            )
           else
             StatsD::Instrument::UDPSink.for_addr(statsd_addr)
           end

data/lib/statsd/instrument/expectation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module StatsD
   module Instrument
     # @private

data/lib/statsd/instrument/udp_sink.rb

@@ -12,11 +12,18 @@ module StatsD
 
       attr_reader :host, :port
 
+      FINALIZER = ->(object_id) do
+        Thread.list.each do |thread|
+          if (store = thread["StatsD::UDPSink"])
+            store.delete(object_id)&.close
+          end
+        end
+      end
+
       def initialize(host, port)
+        ObjectSpace.define_finalizer(self, FINALIZER)
         @host = host
         @port = port
-        @mutex = Mutex.new
-        @socket = nil
       end
 
       def sample?(sample_rate)
@@ -24,38 +31,43 @@ module StatsD
       end
 
       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 SocketError, IOError, SystemCallError => error
-        StatsD.logger.debug do
-          "[StatsD::Instrument::UDPSink] Resetting connection because of #{error.class}: #{error.message}"
+        retried = false
+        begin
+          socket.send(datagram, 0)
+        rescue SocketError, IOError, SystemCallError => error
+          StatsD.logger.debug do
+            "[StatsD::Instrument::UDPSink] Resetting connection because of #{error.class}: #{error.message}"
+          end
+          invalidate_socket
+          if retried
+            StatsD.logger.warn do
+              "[#{self.class.name}] Events were dropped because of #{error.class}: #{error.message}"
+            end
+          else
+            retried = true
+            retry
+          end
         end
-        invalidate_socket
+        self
       end
 
       private
 
-      def with_socket
-        @mutex.synchronize { yield(socket) }
+      def invalidate_socket
+        socket = thread_store.delete(object_id)
+        socket&.close
       end
 
       def socket
-        @socket ||= begin
+        thread_store[object_id] ||= begin
           socket = UDPSocket.new
           socket.connect(@host, @port)
           socket
         end
       end
 
-      def invalidate_socket
-        @mutex.synchronize do
-          @socket = nil
-        end
+      def thread_store
+        Thread.current["StatsD::UDPSink"] ||= {}
       end
     end
   end

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.2.0"
+    VERSION = "3.4.0"
   end
 end

data/statsd-instrument.gemspec

@@ -21,6 +21,4 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.metadata['allowed_push_host'] = "https://rubygems.org"
-
-  spec.add_development_dependency 'concurrent-ruby'
 end

data/test/environment_test.rb

@@ -64,4 +64,13 @@ class EnvironmentTest < Minitest::Test
     )
     assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
+
+  def test_client_from_env_uses_regular_udp_sink_when_buffer_capacity_is_0
+    env = StatsD::Instrument::Environment.new(
+      "STATSD_USE_NEW_CLIENT" => "1",
+      "STATSD_ENV" => "staging",
+      "STATSD_BUFFER_CAPACITY" => "0",
+    )
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
+  end
 end

data/test/udp_sink_test.rb

@@ -32,17 +32,18 @@ module UDPSinkTests
     refute(udp_sink.sample?(0.5))
   end
 
-  def test_parallelism
+  def test_concurrency
     udp_sink = build_sink(@host, @port)
-    50.times.map { |i| Thread.new { udp_sink << "foo:#{i}|c" << "bar:#{i}|c" } }
-    datagrams = []
-
-    while @receiver.wait_readable(2)
-      datagram, _source = @receiver.recvfrom(4000)
-      datagrams += datagram.split("\n")
+    threads = 10.times.map do |i|
+      Thread.new do
+        udp_sink << "foo:#{i}|c" << "bar:#{i}|c" << "baz:#{i}|c" << "plop:#{i}|c"
+      end
     end
-
-    assert_equal(100, datagrams.size)
+    threads.each(&:join)
+    udp_sink.shutdown if udp_sink.respond_to?(:shutdown)
+    assert_equal(40, read_datagrams(40).size)
+  ensure
+    threads&.each(&:kill)
   end
 
   class SimpleFormatter < ::Logger::Formatter
@@ -53,31 +54,39 @@ module UDPSinkTests
 
   def test_sends_datagram_in_signal_handler
     udp_sink = build_sink(@host, @port)
-    Signal.trap("USR1") { udp_sink << "exiting:1|c" }
-
-    pid = fork do
-      sleep(5)
+    Signal.trap("USR1") do
+      udp_sink << "exiting:1|c"
+      udp_sink << "exiting:1|d"
     end
 
+    Process.kill("USR1", Process.pid)
+    assert_equal(["exiting:1|c", "exiting:1|d"], read_datagrams(2))
+  ensure
     Signal.trap("USR1", "DEFAULT")
-
-    Process.kill("USR1", pid)
-    @receiver.wait_readable(1)
-    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
-    Process.kill("KILL", pid)
-  rescue NotImplementedError
-    pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
 
   def test_sends_datagram_before_exit
     udp_sink = build_sink(@host, @port)
-    fork do
+    pid = fork do
       udp_sink << "exiting:1|c"
-      Process.exit(0)
+      udp_sink << "exiting:1|d"
     end
+    Process.wait(pid)
+    assert_equal(["exiting:1|c", "exiting:1|d"], read_datagrams(2))
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
+  end
 
-    @receiver.wait_readable(1)
-    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
+  def test_sends_datagram_in_at_exit_callback
+    udp_sink = build_sink(@host, @port)
+    pid = fork do
+      at_exit do
+        udp_sink << "exiting:1|c"
+        udp_sink << "exiting:1|d"
+      end
+    end
+    Process.wait(pid)
+    assert_equal(["exiting:1|c", "exiting:1|d"], read_datagrams(2))
   rescue NotImplementedError
     pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
@@ -86,11 +95,11 @@ module UDPSinkTests
     udp_sink = build_sink(@host, @port)
     fork do
       udp_sink << "exiting:1|c"
+      udp_sink << "exiting:1|d"
       Process.kill("TERM", Process.pid)
     end
 
-    @receiver.wait_readable(1)
-    assert_equal("exiting:1|c", @receiver.recvfrom_nonblock(100).first)
+    assert_equal(["exiting:1|c", "exiting:1|d"], read_datagrams(2))
   rescue NotImplementedError
     pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
@@ -101,6 +110,19 @@ module UDPSinkTests
     @sink_class.new(host, port)
   end
 
+  def read_datagrams(count, timeout: ENV["CI"] ? 5 : 1)
+    datagrams = []
+    count.times do
+      if @receiver.wait_readable(timeout)
+        datagrams += @receiver.recvfrom(2000).first.lines(chomp: true)
+        break if datagrams.size >= count
+      else
+        break
+      end
+    end
+    datagrams
+  end
+
   class UDPSinkTest < Minitest::Test
     include UDPSinkTests
 
@@ -127,8 +149,9 @@ module UDPSinkTests
         seq = sequence("connect_fail_connect_succeed")
         socket.expects(:connect).with("localhost", 8125).in_sequence(seq)
         socket.expects(:send).raises(Errno::EDESTADDRREQ).in_sequence(seq)
+        socket.expects(:close).in_sequence(seq)
         socket.expects(:connect).with("localhost", 8125).in_sequence(seq)
-        socket.expects(:send).returns(1).in_sequence(seq)
+        socket.expects(:send).twice.returns(1).in_sequence(seq)
 
         udp_sink = build_sink("localhost", 8125)
         udp_sink << "foo:1|c"
@@ -145,7 +168,7 @@ module UDPSinkTests
     end
   end
 
-  class BatchedUDPSinkTest < Minitest::Test
+  module BatchedUDPSinkTests
     include UDPSinkTests
 
     def setup
@@ -154,28 +177,24 @@ module UDPSinkTests
       @host = @receiver.addr[2]
       @port = @receiver.addr[1]
       @sink_class = StatsD::Instrument::BatchedUDPSink
+      @sinks = []
     end
 
     def teardown
       @receiver.close
+      @sinks.each(&:shutdown)
     end
 
-    def test_parallelism_buffering
-      udp_sink = build_sink(@host, @port)
-      50.times.map do |i|
-        Thread.new do
-          udp_sink << "foo:#{i}|c" << "bar:#{i}|c" << "baz:#{i}|c" << "plop:#{i}|c"
-        end
-      end
-
-      datagrams = []
-
-      while @receiver.wait_readable(2)
-        datagram, _source = @receiver.recvfrom(1000)
-        datagrams += datagram.split("\n")
-      end
+    private
 
-      assert_equal(200, datagrams.size)
+    def build_sink(host = @host, port = @port)
+      sink = @sink_class.new(host, port, buffer_capacity: 50)
+      @sinks << sink
+      sink
     end
   end
+
+  class BatchedUDPSinkTest < Minitest::Test
+    include BatchedUDPSinkTests
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,22 +10,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2022-08-29 00:00:00.000000000 Z
+dependencies: []
 description: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
   StatsD instrumentation into your code.
 email:
@@ -35,8 +21,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/CODEOWNERS"
-- ".github/probots.yml"
 - ".github/workflows/benchmark.yml"
+- ".github/workflows/cla.yml"
 - ".github/workflows/lint.yml"
 - ".github/workflows/tests.yml"
 - ".gitignore"
@@ -49,6 +35,7 @@ files:
 - README.md
 - Rakefile
 - benchmark/README.md
+- benchmark/local-udp-throughput
 - benchmark/send-metrics-to-dev-null-log
 - benchmark/send-metrics-to-local-udp-receiver
 - bin/rake

data/.github/probots.yml

@@ -1,2 +0,0 @@
-enabled:
-  - cla