statsd-instrument 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62f90038a90bccc54c0fe5ac2fe1a2449e8662183e9b9a0cac209e5ae22a07c7
-  data.tar.gz: e620363a10bff05710ce52f6869364e378a0979e2ef53cc86c56f8c7fe491d91
+  metadata.gz: bcbaac2cd4178c61bfcb484c45931bb387d81dfa632fbd114bba126c393beb75
+  data.tar.gz: d1101fbc534b6612ff76a282ab45d37aad3a0c185b3ccedf6dcf2ef78ce85bb1
 SHA512:
-  metadata.gz: 18836250885562c7862db1e515c8f8433e43cf795b886800e8a40fae7e7ebead2a120656e6f7654d5c3b87c9f364d3861441593f42dfda7fa69479146b800842
-  data.tar.gz: 6915ee31b5bab72a8d52ef588f6fa90e1df4e821e1aaa96cf7523b1392d49bdc56003de4e3f09e818aee21e2d094e9671b2b2297e7b3f597ca193dafbf03824a
+  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/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

@@ -20,9 +20,15 @@ Naming/FileName:
 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,6 +6,12 @@ section below.
 
 ### Unreleased changes
 
+- 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

data/README.md

@@ -42,13 +42,14 @@ 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

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,38 +7,6 @@ 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
-end
-
-intermediate_results_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_NAME)}"
-log_filename = "#{Dir.tmpdir}/statsd-instrument-benchmarks/#{File.basename($PROGRAM_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",
-  "STATSD_FLUSH_INTERVAL" => "0",
-)).client
-
-batched_udp_client = StatsD::Instrument::Environment.new(ENV.to_h.merge(
-  "STATSD_ADDR" => "#{receiver.addr[2]}:#{receiver.addr[1]}",
-  "STATSD_IMPLEMENTATION" => "dogstatsd",
-  "STATSD_ENV" => "production",
-)).client
-
 def send_metrics(client)
   client.increment("StatsD.increment", 10)
   client.measure("StatsD.measure") { 1 + 1 }
@@ -50,37 +18,66 @@ def send_metrics(client)
   end
 end
 
-report = Benchmark.ips do |bench|
-  bench.report("local UDP sync (branch: #{branch}, sha: #{revision[0, 7]})") do
-    send_metrics(udp_client)
+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
 
-  bench.report("local UDP batched (branch: #{branch}, sha: #{revision[0, 7]})") do
-    send_metrics(batched_udp_client)
+  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)
 
-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)
+  end
 
-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
 
-log_file.close
-logs = File.read(log_filename)
-unless logs.empty?
-  puts
-  puts "==== logs ===="
-  puts logs
-end
+benchmark_implementation("UDP sync", "STATSD_BUFFER_CAPACITY" => "0")
+benchmark_implementation("UDP batched")

data/lib/statsd/instrument/batched_udp_sink.rb

@@ -5,9 +5,7 @@ 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
       DEFAULT_THREAD_PRIORITY = 100
-      DEFAULT_FLUSH_THRESHOLD = 50
       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
@@ -28,9 +26,7 @@ module StatsD
       def initialize(
         host,
         port,
-        flush_interval: DEFAULT_FLUSH_INTERVAL,
         thread_priority: DEFAULT_THREAD_PRIORITY,
-        flush_threshold: DEFAULT_FLUSH_THRESHOLD,
         buffer_capacity: DEFAULT_BUFFER_CAPACITY,
         max_packet_size: DEFAULT_MAX_PACKET_SIZE
       )
@@ -39,8 +35,6 @@ module StatsD
         @dispatcher = Dispatcher.new(
           host,
           port,
-          flush_interval,
-          flush_threshold,
           buffer_capacity,
           thread_priority,
           max_packet_size,
@@ -61,112 +55,85 @@ module StatsD
         @dispatcher.shutdown(*args)
       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
+      class Buffer < SizedQueue
+        def push_nonblock(item)
+          push(item, true)
+        rescue ThreadError, ClosedQueueError
+          nil
+        end
+
+        def inspect
+          "<#{self.class.name}:#{object_id} capacity=#{max} size=#{size}>"
+        end
+
+        def pop_nonblock
+          pop(true)
+        rescue ThreadError
+          nil
         end
+      end
 
-        def initialize(host, port, flush_interval, flush_threshold, buffer_capacity, thread_priority, max_packet_size)
-          @host = host
-          @port = port
+      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
-          @flush_threshold = flush_threshold
-          @buffer_capacity = buffer_capacity
           @thread_priority = thread_priority
           @max_packet_size = max_packet_size
-          @buffer = BUFFER_CLASS.new
+          @buffer_capacity = buffer_capacity
+          @buffer = Buffer.new(buffer_capacity)
           @dispatcher_thread = Thread.new { dispatch }
           @pid = Process.pid
-          @monitor = Monitor.new
-          @condition = @monitor.new_cond
         end
 
         def <<(datagram)
-          if thread_healthcheck
-            @buffer << datagram
-
-            # To avoid sending too many signals when the thread is already flushing
-            # We only signal when the queue size is a multiple of `flush_threshold`
-            if @buffer.size % @flush_threshold == 0
-              wakeup_thread
-            end
-
-            # A SizedQueue would be perfect, except that it doesn't have a timeout
-            # Ref: https://bugs.ruby-lang.org/issues/18774
-            if @buffer.size >= @buffer_capacity
-              StatsD.logger.warn do
-                "[#{self.class.name}] Max buffer size reached (#{@buffer_capacity}), pausing " \
-                  "thread##{Thread.current.object_id}"
-              end
-              before = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
-              @monitor.synchronize do
-                while @buffer.size >= @buffer_capacity && @dispatcher_thread.alive?
-                  @condition.wait(0.01)
-                end
-              end
-              duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - before
-              StatsD.logger.warn do
-                "[#{self.class.name}] thread##{Thread.current.object_id} resumed after #{duration.round(2)}ms"
-              end
-            end
-          else
-            flush
+          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
 
           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
 
-        def wakeup_thread
-          begin
-            @monitor.synchronize do
-              @condition.signal
-            end
-          rescue ThreadError
-            # Can't synchronize from trap context
-            Thread.new { wakeup_thread }.join
-            return
-          end
-
-          begin
-            @dispatcher_thread&.run
-          rescue ThreadError # Somehow the thread just died
-            thread_healthcheck
-          end
-        end
-
         NEWLINE = "\n".b.freeze
-        def flush
-          return if @buffer.empty?
 
-          datagrams = @buffer.shift(@buffer.size)
-
-          until datagrams.empty?
-            packet = String.new(datagrams.shift, 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
 
@@ -196,26 +163,13 @@ module StatsD
         def dispatch
           until @interrupted
             begin
-              start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              flush
-
-              # Other threads may have queued more events while we were doing IO
-              flush while @buffer.size > @flush_threshold
-
-              next_sleep_duration = @flush_interval - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start)
-
-              if next_sleep_duration > 0
-                @monitor.synchronize do
-                  @condition.wait(next_sleep_duration)
-                end
-              end
+              flush(blocking: true)
             rescue => error
               report_error(error)
             end
           end
 
-          flush
-          invalidate_socket
+          flush(blocking: false)
         end
 
         def report_error(error)
@@ -223,40 +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
-          begin
-            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.warn do
-                "[#{self.class.name}] Events were dropped because of #{error.class}: #{error.message}"
-              end
-            else
-              retried = true
-              retry
-            end
-          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,12 +86,12 @@ 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", StatsD::Instrument::BatchedUDPSink::DEFAULT_FLUSH_INTERVAL))
+      def statsd_buffer_capacity
+        Integer(env.fetch("STATSD_BUFFER_CAPACITY", StatsD::Instrument::BatchedUDPSink::DEFAULT_BUFFER_CAPACITY))
       end
 
-      def statsd_buffer_capacity
-        Float(env.fetch("STATSD_BUFFER_CAPACITY", StatsD::Instrument::BatchedUDPSink::DEFAULT_BUFFER_CAPACITY))
+      def statsd_batching?
+        statsd_buffer_capacity > 0 && Float(env.fetch("STATSD_FLUSH_INTERVAL", 1.0)) > 0.0
       end
 
       def statsd_max_packet_size
@@ -97,10 +105,9 @@ module StatsD
       def default_sink_for_environment
         case environment
         when "production", "staging"
-          if statsd_flush_interval > 0.0
+          if statsd_batching?
             StatsD::Instrument::BatchedUDPSink.for_addr(
               statsd_addr,
-              flush_interval: statsd_flush_interval,
               buffer_capacity: statsd_buffer_capacity,
               max_packet_size: statsd_max_packet_size,
             )

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,43 +31,43 @@ module StatsD
       end
 
       def <<(datagram)
-        with_socket { |socket| socket.send(datagram, 0) }
-        self
-      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 synchronize(&block)
-        @mutex.synchronize(&block)
-      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.
-        yield
-      end
-
-      def with_socket
-        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
-        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.3.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

@@ -34,15 +34,14 @@ module UDPSinkTests
 
   def test_concurrency
     udp_sink = build_sink(@host, @port)
-    threads = 50.times.map { |i| Thread.new { udp_sink << "foo:#{i}|c" << "bar:#{i}|c" } }
-    datagrams = []
-
-    while @receiver.wait_readable(2)
-      datagram, _source = @receiver.recvfrom(4096)
-      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
@@ -111,11 +110,12 @@ module UDPSinkTests
     @sink_class.new(host, port)
   end
 
-  def read_datagrams(count, timeout: 2)
+  def read_datagrams(count, timeout: ENV["CI"] ? 5 : 1)
     datagrams = []
     count.times do
       if @receiver.wait_readable(timeout)
-        datagrams += @receiver.recvfrom_nonblock(1000).first.lines(chomp: true)
+        datagrams += @receiver.recvfrom(2000).first.lines(chomp: true)
+        break if datagrams.size >= count
       else
         break
       end
@@ -149,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"
@@ -187,52 +188,13 @@ module UDPSinkTests
     private
 
     def build_sink(host = @host, port = @port)
-      sink = @sink_class.new(host, port, flush_threshold: default_flush_threshold, buffer_capacity: 50)
+      sink = @sink_class.new(host, port, buffer_capacity: 50)
       @sinks << sink
       sink
     end
-
-    def default_flush_threshold
-      StatsD::Instrument::BatchedUDPSink::DEFAULT_FLUSH_THRESHOLD
-    end
   end
 
   class BatchedUDPSinkTest < Minitest::Test
     include BatchedUDPSinkTests
-
-    def test_concurrency_buffering
-      udp_sink = build_sink(@host, @port)
-      threads = 50.times.map do |i|
-        Thread.new do
-          udp_sink << "foo:#{i}|c" << "bar:#{i}|c" << "baz:#{i}|c" << "plop:#{i}|c"
-        end
-      end
-      threads.each(&:join)
-      assert_equal(200, read_datagrams(10, timeout: 2).size)
-    ensure
-      threads&.each(&:kill)
-    end
-  end
-
-  class LowThresholdBatchedUDPSinkTest < Minitest::Test
-    include BatchedUDPSinkTests
-
-    def test_sends_datagram_when_termed
-      # When the main thread exit, the dispatcher thread is aborted
-      # and there's no exceptions or anything like that to rescue.
-      # So if the dispatcher thread poped some events from the buffer
-      # but didn't sent them yet, then they may be lost.
-      skip("Unfortunately this can't be guaranteed")
-    end
-    alias_method :test_sends_datagram_in_at_exit_callback, :test_sends_datagram_when_termed
-    alias_method :test_sends_datagram_before_exit, :test_sends_datagram_when_termed
-
-    private
-
-    # We run the same tests again, but this time we wake up the dispatcher
-    # thread on every call to make sure trap context is properly handled
-    def default_flush_threshold
-      1
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,22 +10,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-26 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:
@@ -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