dogstatsd-ruby 5.3.1 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 539ec3d4e02bd8784df4d032b0f8e96ebb2a582b510ff5e27c6e7cfff4515926
-  data.tar.gz: d8ecf4c6724e491aaea6d738cc255891b55119987b1ca5665087d506552135ee
+  metadata.gz: d780ad7a840c021ee3cb31a9e8b512ef7ccff4b82b14be9e300206d3a07cc61e
+  data.tar.gz: 2da798fe3a84f313c5c84655136597c562e3dc1bfaa24f8ba6441ef722c7cc45
 SHA512:
-  metadata.gz: d615efd205f7858c55b9864e1d001d607dcb39a47a26c87f5e27402b25834cf750fb3904d10d667c63a437587d38ba315d7a3c609b7709bc28a8bc8138d30eef
-  data.tar.gz: 254bf33695141f521d55d5f5b9c4d6b3abf2408b6b231263949094cbc2c9f531bf3ff2aea92ae0f11d505bbb8d25a789a2c0da76d9a065b713f9dc9b5b9d836d
+  metadata.gz: 8f92d7dab8099d571c291e26497020e53087ccdbeecfd84d955778f484112f9b94fb0f4ec7d043b9efabd5d249333168fa44e4fe6e54ba4c9541447b92983ceb
+  data.tar.gz: 8dadc086c84a821d4a1b1824a25ea4861bdf0b6a36cfcf8c50a8d06e19d6853c35974dbefb03fedc9ccd7a3f57ff13a19d206c5eef152c1aa5ffbc1f789da1bc

data/README.md

@@ -180,6 +180,15 @@ There are three different kinds of messages:
 
 There is also an implicit message which closes the queue which will cause the sender thread to finish processing and exit.
 
+
+```ruby
+statsd = Datadog::Statsd.new('localhost', 8125)
+```
+
+The message queue's maximum size (in messages) is given by the `sender_queue_size` argument, and has appropriate defaults for UDP (2048) and UDS (512).
+
+The `buffer_flush_interval`, if enabled, is implemented with an additional thread which manages the timing of those flushes.  This additional thread is used even if `single_thread: true`.
+
 ### Usual workflow
 
 You push metrics to the statsd client which writes them quickly to the sender message queue. The sender thread receives those message, buffers them and flushes them to the connection when the buffer limit is reached.
@@ -204,7 +213,13 @@ When using the `single_thread: true` mode, instances of `Datadog::Statsd` are st
 
 ## Versioning
 
-This Ruby gem is using [Semantic Versioning](https://guides.rubygems.org/patterns/#semantic-versioning) but please note that supported Ruby versions can change in a minor release of this library. As much as possible, we will add a "future deprecation" message in the minor release preceding the one dropping the support.
+This Ruby gem is using [Semantic Versioning](https://guides.rubygems.org/patterns/#semantic-versioning) but please note that supported Ruby versions can change in a minor release of this library.
+As much as possible, we will add a "future deprecation" message in the minor release preceding the one dropping the support.
+
+## Ruby Versions
+
+This gem supports and is tested on Ruby minor versions 2.1 through 3.1.
+Support for Ruby 2.0 was dropped in version 5.4.0.
 
 ## Credits
 

data/lib/datadog/statsd/connection.rb

@@ -38,7 +38,7 @@ module Datadog
           end
         end
 
-        telemetry.dropped(packets: 1, bytes: payload.length) if telemetry
+        telemetry.dropped_writer(packets: 1, bytes: payload.length) if telemetry
         logger.error { "Statsd: #{boom.class} #{boom}" } if logger
         nil
       end

data/lib/datadog/statsd/connection_cfg.rb

@@ -0,0 +1,76 @@
+module Datadog
+  class Statsd
+    class ConnectionCfg
+      attr_reader :host
+      attr_reader :port
+      attr_reader :socket_path
+      attr_reader :transport_type
+
+      def initialize(host: nil, port: nil, socket_path: nil)
+        initialize_with_constructor_args(host: host, port: port, socket_path: socket_path) ||
+          initialize_with_env_vars ||
+          initialize_with_defaults
+      end
+
+      def make_connection(**params)
+        case @transport_type
+        when :udp
+          UDPConnection.new(@host, @port, **params)
+        when :uds
+          UDSConnection.new(@socket_path, **params)
+        end
+      end
+
+      private
+
+      DEFAULT_HOST = '127.0.0.1'
+      DEFAULT_PORT = 8125
+
+      def initialize_with_constructor_args(host: nil, port: nil, socket_path: nil)
+        try_initialize_with(host: host, port: port, socket_path: socket_path,
+          not_both_error_message: 
+            "Both UDP: (host/port #{host}:#{port}) and UDS (socket_path #{socket_path}) " +
+            "constructor arguments were given. Use only one or the other.",
+          )
+      end
+
+      def initialize_with_env_vars()
+        try_initialize_with(
+          host: ENV['DD_AGENT_HOST'],
+          port: ENV['DD_DOGSTATSD_PORT'] && ENV['DD_DOGSTATSD_PORT'].to_i,
+          socket_path: ENV['DD_DOGSTATSD_SOCKET'],
+          not_both_error_message:
+            "Both UDP (DD_AGENT_HOST/DD_DOGSTATSD_PORT #{ENV['DD_AGENT_HOST']}:#{ENV['DD_DOGSTATSD_PORT']}) " +
+            "and UDS (DD_DOGSTATSD_SOCKET #{ENV['DD_DOGSTATSD_SOCKET']}) environment variables are set. " +
+            "Set only one or the other.",
+        )
+      end
+
+      def initialize_with_defaults()
+        try_initialize_with(host: DEFAULT_HOST, port: DEFAULT_PORT)
+      end
+
+      def try_initialize_with(host: nil, port: nil, socket_path: nil, not_both_error_message: "")
+        if (host || port) && socket_path
+          raise ArgumentError, not_both_error_message
+        end
+
+        if host || port 
+          @host = host || DEFAULT_HOST
+          @port = port || DEFAULT_PORT
+          @socket_path = nil
+          @transport_type = :udp
+          return true
+        elsif socket_path
+          @host = nil
+          @port = nil
+          @socket_path = socket_path
+          @transport_type = :uds
+          return true
+        end
+
+        return false
+      end
+    end
+  end
+end

data/lib/datadog/statsd/forwarder.rb

@@ -7,13 +7,14 @@ module Datadog
       attr_reader :transport_type
 
       def initialize(
-        host: nil,
-        port: nil,
-        socket_path: nil,
+        connection_cfg: nil,
 
         buffer_max_payload_size: nil,
         buffer_max_pool_size: nil,
         buffer_overflowing_stategy: :drop,
+        buffer_flush_interval: nil,
+
+        sender_queue_size: nil,
 
         telemetry_flush_interval: nil,
         global_tags: [],
@@ -22,24 +23,20 @@ module Datadog
 
         logger: nil
       )
-        @transport_type = socket_path.nil? ? :udp : :uds
+        @transport_type = connection_cfg.transport_type
 
         if telemetry_flush_interval
           @telemetry = Telemetry.new(telemetry_flush_interval,
             global_tags: global_tags,
-            transport_type: transport_type
+            transport_type: @transport_type
           )
         end
 
-        @connection = case transport_type
-                      when :udp
-                        UDPConnection.new(host, port, logger: logger, telemetry: telemetry)
-                      when :uds
-                        UDSConnection.new(socket_path, logger: logger, telemetry: telemetry)
-                      end
+        @connection = connection_cfg.make_connection(logger: logger, telemetry: telemetry)
 
         # Initialize buffer
-        buffer_max_payload_size ||= (transport_type == :udp ? UDP_DEFAULT_BUFFER_SIZE : UDS_DEFAULT_BUFFER_SIZE)
+        buffer_max_payload_size ||= (@transport_type == :udp ?
+                                     UDP_DEFAULT_BUFFER_SIZE : UDS_DEFAULT_BUFFER_SIZE)
 
         if buffer_max_payload_size <= 0
           raise ArgumentError, 'buffer_max_payload_size cannot be <= 0'
@@ -54,7 +51,21 @@ module Datadog
           max_pool_size: buffer_max_pool_size || DEFAULT_BUFFER_POOL_SIZE,
           overflowing_stategy: buffer_overflowing_stategy,
         )
-        @sender = (single_thread ? SingleThreadSender : Sender).new(buffer, logger: logger)
+
+        sender_queue_size ||= (@transport_type == :udp ?
+                               UDP_DEFAULT_SENDER_QUEUE_SIZE : UDS_DEFAULT_SENDER_QUEUE_SIZE)
+
+        @sender = single_thread ?
+          SingleThreadSender.new(
+            buffer,
+            logger: logger,
+            flush_interval: buffer_flush_interval) :
+          Sender.new(
+            buffer,
+            logger: logger,
+            flush_interval: buffer_flush_interval,
+            telemetry: @telemetry,
+            queue_size: sender_queue_size)
         @sender.start
       end
 

data/lib/datadog/statsd/sender.rb

@@ -12,10 +12,17 @@ module Datadog
     class Sender
       CLOSEABLE_QUEUES = Queue.instance_methods.include?(:close)
 
-      def initialize(message_buffer, logger: nil)
+      def initialize(message_buffer, telemetry: nil, queue_size: UDP_DEFAULT_BUFFER_SIZE, logger: nil, flush_interval: nil, queue_class: Queue, thread_class: Thread)
         @message_buffer = message_buffer
+        @telemetry = telemetry
+        @queue_size = queue_size
         @logger = logger
         @mx = Mutex.new
+        @queue_class = queue_class
+        @thread_class = thread_class
+        if flush_interval
+          @flush_timer = Datadog::Statsd::Timer.new(flush_interval) { flush(sync: true) }
+        end
       end
 
       def flush(sync: false)
@@ -42,7 +49,7 @@ module Datadog
         return unless message_queue
 
         # Initialize and get the thread's sync queue
-        queue = (Thread.current[:statsd_sync_queue] ||= Queue.new)
+        queue = (@thread_class.current[:statsd_sync_queue] ||= @queue_class.new)
         # tell sender-thread to notify us in the current
         # thread's queue
         message_queue.push(queue)
@@ -68,19 +75,26 @@ module Datadog
             @message_queue = nil
             message_buffer.reset
             start
+            @flush_timer.start if @flush_timer && @flush_timer.stop?
           }
         end
 
-        message_queue << message
+        if message_queue.length <= @queue_size
+          message_queue << message
+        else
+          @telemetry.dropped_queue(packets: 1, bytes: message.bytesize) if @telemetry
+        end
       end
 
       def start
         raise ArgumentError, 'Sender already started' if message_queue
 
         # initialize a new message queue for the background thread
-        @message_queue = Queue.new
+        @message_queue = @queue_class.new
         # start background thread
-        @sender_thread = Thread.new(&method(:send_loop))
+        @sender_thread = @thread_class.new(&method(:send_loop))
+        @sender_thread.name = "Statsd Sender" unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+        @flush_timer.start if @flush_timer
       end
 
       if CLOSEABLE_QUEUES
@@ -91,6 +105,7 @@ module Datadog
           message_queue = @message_queue
           message_queue.close if message_queue
 
+          @flush_timer.stop if @flush_timer
           sender_thread = @sender_thread
           sender_thread.join if sender_thread && join_worker
         end
@@ -102,6 +117,7 @@ module Datadog
           message_queue = @message_queue
           message_queue << :close if message_queue
 
+          @flush_timer.stop if @flush_timer
           sender_thread = @sender_thread
           sender_thread.join if sender_thread && join_worker
         end
@@ -123,7 +139,7 @@ module Datadog
             case message
             when :flush
               message_buffer.flush
-            when Queue
+            when @queue_class
               message.push(:go_on)
             else
               message_buffer.add(message)
@@ -145,7 +161,7 @@ module Datadog
               break
             when :flush
               message_buffer.flush
-            when Queue
+            when @queue_class
               message.push(:go_on)
             else
               message_buffer.add(message)

data/lib/datadog/statsd/single_thread_sender.rb

@@ -7,10 +7,13 @@ module Datadog
     # It is using current Process.PID to check it is the result of a recent fork
     # and it is reseting the MessageBuffer if that's the case.
     class SingleThreadSender
-      def initialize(message_buffer, logger: nil)
+      def initialize(message_buffer, logger: nil, flush_interval: nil)
         @message_buffer = message_buffer
         @logger = logger
         @mx = Mutex.new
+        if flush_interval
+          @flush_timer = Datadog::Statsd::Timer.new(flush_interval) { flush }
+        end
         # store the pid for which this sender has been created
         update_fork_pid
       end
@@ -21,6 +24,7 @@ module Datadog
           # not send, they belong to the parent process, let's clear the buffer.
           if forked?
             @message_buffer.reset
+            @flush_timer.start if @flush_timer && @flush_timer.stop?
             update_fork_pid
           end
           @message_buffer.add(message)
@@ -33,12 +37,12 @@ module Datadog
         }
       end
 
-      # Compatibility with `Sender`
       def start()
+        @flush_timer.start if @flush_timer
       end
 
-      # Compatibility with `Sender`
       def stop()
+        @flush_timer.stop if @flush_timer
       end
 
       # Compatibility with `Sender`

data/lib/datadog/statsd/telemetry.rb

@@ -9,8 +9,12 @@ module Datadog
       attr_reader :service_checks
       attr_reader :bytes_sent
       attr_reader :bytes_dropped
+      attr_reader :bytes_dropped_queue
+      attr_reader :bytes_dropped_writer
       attr_reader :packets_sent
       attr_reader :packets_dropped
+      attr_reader :packets_dropped_queue
+      attr_reader :packets_dropped_writer
 
       # Rough estimation of maximum telemetry message size without tags
       MAX_TELEMETRY_MESSAGE_SIZE_WT_TAGS = 50 # bytes
@@ -40,8 +44,12 @@ module Datadog
         @service_checks = 0
         @bytes_sent = 0
         @bytes_dropped = 0
+        @bytes_dropped_queue = 0
+        @bytes_dropped_writer = 0
         @packets_sent = 0
         @packets_dropped = 0
+        @packets_dropped_queue = 0
+        @packets_dropped_writer = 0
         @next_flush_time = now_in_s + @flush_interval
       end
 
@@ -54,9 +62,18 @@ module Datadog
         @packets_sent += packets
       end
 
-      def dropped(bytes: 0, packets: 0)
+      def dropped_queue(bytes: 0, packets: 0)
         @bytes_dropped += bytes
+        @bytes_dropped_queue += bytes
         @packets_dropped += packets
+        @packets_dropped_queue += packets
+      end
+
+      def dropped_writer(bytes: 0, packets: 0)
+        @bytes_dropped += bytes
+        @bytes_dropped_writer += bytes
+        @packets_dropped += packets
+        @packets_dropped_writer += packets
       end
 
       def should_flush?
@@ -70,8 +87,12 @@ module Datadog
           sprintf(pattern, 'service_checks', @service_checks),
           sprintf(pattern, 'bytes_sent', @bytes_sent),
           sprintf(pattern, 'bytes_dropped', @bytes_dropped),
+          sprintf(pattern, 'bytes_dropped_queue', @bytes_dropped_queue),
+          sprintf(pattern, 'bytes_dropped_writer', @bytes_dropped_writer),
           sprintf(pattern, 'packets_sent', @packets_sent),
           sprintf(pattern, 'packets_dropped', @packets_dropped),
+          sprintf(pattern, 'packets_dropped_queue', @packets_dropped_queue),
+          sprintf(pattern, 'packets_dropped_writer', @packets_dropped_writer),
         ]
       end
 

data/lib/datadog/statsd/timer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    class Timer
+      def initialize(interval, &callback)
+        @mx = Mutex.new
+        @cv = ConditionVariable.new
+        @interval = interval
+        @callback = callback
+        @stop = true
+      end
+
+      def start
+        return unless stop?
+
+        @stop = false
+        @thread = Thread.new do
+          last_execution_time = current_time
+          @mx.synchronize do
+            until @stop
+              timeout = @interval - (current_time - last_execution_time)
+              @cv.wait(@mx, timeout > 0 ? timeout : 0)
+              last_execution_time = current_time
+              @callback.call
+            end
+          end
+        end
+        @thread.name = 'Statsd Timer' unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+      end
+
+      def stop
+        return if @thread.nil?
+
+        @stop = true
+        @mx.synchronize do
+          @cv.signal
+        end
+        @thread.join
+        @thread = nil
+      end
+
+      def stop?
+        @thread.nil? || @thread.stop?
+      end
+
+      private
+
+      if Process.const_defined?(:CLOCK_MONOTONIC)
+        def current_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      else
+        def current_time
+          Time.now
+        end
+      end
+    end
+  end
+end

data/lib/datadog/statsd/udp_connection.rb

@@ -5,20 +5,17 @@ require_relative 'connection'
 module Datadog
   class Statsd
     class UDPConnection < Connection
-      DEFAULT_HOST = '127.0.0.1'
-      DEFAULT_PORT = 8125
-
-      # StatsD host. Defaults to 127.0.0.1.
+      # StatsD host.
       attr_reader :host
 
-      # StatsD port. Defaults to 8125.
+      # StatsD port.
       attr_reader :port
 
       def initialize(host, port, **kwargs)
         super(**kwargs)
 
-        @host = host || ENV.fetch('DD_AGENT_HOST', DEFAULT_HOST)
-        @port = port || ENV.fetch('DD_DOGSTATSD_PORT', DEFAULT_PORT).to_i
+        @host = host
+        @port = port
         @socket = nil
       end
 

data/lib/datadog/statsd/version.rb

@@ -4,6 +4,6 @@ require_relative 'connection'
 
 module Datadog
   class Statsd
-    VERSION = '5.3.1'
+    VERSION = '5.4.0'
   end
 end

data/lib/datadog/statsd.rb

@@ -5,14 +5,13 @@ require_relative 'statsd/version'
 require_relative 'statsd/telemetry'
 require_relative 'statsd/udp_connection'
 require_relative 'statsd/uds_connection'
+require_relative 'statsd/connection_cfg'
 require_relative 'statsd/message_buffer'
 require_relative 'statsd/serialization'
 require_relative 'statsd/sender'
 require_relative 'statsd/single_thread_sender'
 require_relative 'statsd/forwarder'
-
-$deprecation_message_mutex = Mutex.new
-$deprecation_message_done = false
+require_relative 'statsd/timer'
 
 # = Datadog::Statsd: A DogStatsd client (https://www.datadoghq.com)
 #
@@ -43,7 +42,12 @@ module Datadog
     UDP_DEFAULT_BUFFER_SIZE = 1_432
     UDS_DEFAULT_BUFFER_SIZE = 8_192
     DEFAULT_BUFFER_POOL_SIZE = Float::INFINITY
+
+    UDP_DEFAULT_SENDER_QUEUE_SIZE = 2048
+    UDS_DEFAULT_SENDER_QUEUE_SIZE = 512
+
     MAX_EVENT_SIZE = 8 * 1_024
+
     # minimum flush interval for the telemetry in seconds
     DEFAULT_TELEMETRY_FLUSH_INTERVAL = 10
 
@@ -72,6 +76,8 @@ module Datadog
     # @option [Logger] logger for debugging
     # @option [Integer] buffer_max_payload_size max bytes to buffer
     # @option [Integer] buffer_max_pool_size max messages to buffer
+    # @option [Integer] sender_queue_size size of the sender queue in number of buffers (multi-thread only)
+    # @option [Numeric] buffer_flush_interval interval in second to flush buffer
     # @option [String] socket_path unix socket path
     # @option [Float] default sample rate if not overridden
     # @option [Boolean] single_thread flushes the metrics on the main thread instead of in a companion thread
@@ -87,6 +93,9 @@ module Datadog
       buffer_max_payload_size: nil,
       buffer_max_pool_size: nil,
       buffer_overflowing_stategy: :drop,
+      buffer_flush_interval: nil,
+
+      sender_queue_size: nil,
 
       logger: nil,
 
@@ -104,23 +113,12 @@ module Datadog
       @serializer = Serialization::Serializer.new(prefix: @prefix, global_tags: tags)
       @sample_rate = sample_rate
 
-      # deprecation message for ruby < 2.1.0 users as we will drop support for ruby 2.0
-      # in dogstatsd-ruby 5.4.0
-      # TODO(remy): remove this message and the two global vars used in dogstatd-ruby 5.4.0
-      if RUBY_VERSION < '2.1.0' && $deprecation_message_mutex.try_lock && !$deprecation_message_done
-        if logger != nil
-          logger.warn { "deprecation: dogstatsd-ruby will drop support of Ruby < 2.1.0 in a next minor release" }
-        else
-          puts("warning: deprecation: dogstatsd-ruby will drop support of Ruby < 2.1.0 in a next minor release")
-        end
-        $deprecation_message_done = true
-        $deprecation_message_mutex.unlock
-      end
-
       @forwarder = Forwarder.new(
-        host: host,
-        port: port,
-        socket_path: socket_path,
+        connection_cfg: ConnectionCfg.new(
+          host: host,
+          port: port,
+          socket_path: socket_path,
+        ),
 
         global_tags: tags,
         logger: logger,
@@ -130,6 +128,9 @@ module Datadog
         buffer_max_payload_size: buffer_max_payload_size,
         buffer_max_pool_size: buffer_max_pool_size,
         buffer_overflowing_stategy: buffer_overflowing_stategy,
+        buffer_flush_interval: buffer_flush_interval,
+
+        sender_queue_size: sender_queue_size,
 
         telemetry_flush_interval: telemetry_enable ? telemetry_flush_interval : nil,
       )
@@ -137,12 +138,13 @@ module Datadog
 
     # yield a new instance to a block and close it when done
     # for short-term use-cases that don't want to close the socket manually
-    def self.open(*args)
-      instance = new(*args)
+    # TODO: replace with ... once we are on ruby 2.7
+    def self.open(*args, **kwargs)
+      instance = new(*args, **kwargs)
 
       yield instance
     ensure
-      instance.close
+      instance.close if instance
     end
 
     # Sends an increment (count = 1) for the given stat to the statsd server.
@@ -150,6 +152,7 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by increment value, default 1
     # @see #count
@@ -164,6 +167,7 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by decrement value, default 1
     # @see #count
@@ -179,13 +183,14 @@ module Datadog
     # @param [Integer] count count
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     def count(stat, count, opts = EMPTY_OPTIONS)
       opts = { sample_rate: opts } if opts.is_a?(Numeric)
       send_stats(stat, count, COUNTER_TYPE, opts)
     end
 
-    # Sends an arbitary gauge value for the given stat to the statsd server.
+    # Sends an arbitrary gauge value for the given stat to the statsd server.
     #
     # This is useful for recording things like available disk space,
     # memory usage, and the like, which have different semantics than
@@ -195,6 +200,7 @@ module Datadog
     # @param [Numeric] value gauge value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.gauge('user.count', User.count)
@@ -209,6 +215,7 @@ module Datadog
     # @param [Numeric] value histogram value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.histogram('user.count', User.count)
@@ -222,6 +229,7 @@ module Datadog
     # @param [Numeric] value distribution value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.distribution('user.count', User.count)
@@ -238,6 +246,7 @@ module Datadog
     # @param [Integer] ms timing in milliseconds
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     def timing(stat, ms, opts = EMPTY_OPTIONS)
       opts = { sample_rate: opts } if opts.is_a?(Numeric)
@@ -252,6 +261,7 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @yield The operation to be timed
     # @see #timing
@@ -271,6 +281,7 @@ module Datadog
     # @param [Numeric] value set value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Record a unique visitory by id:
     #   $statsd.set('visitors.uniques', User.id)
@@ -382,17 +393,10 @@ module Datadog
     attr_reader :serializer
     attr_reader :forwarder
 
-    PROCESS_TIME_SUPPORTED = (RUBY_VERSION >= '2.1.0')
     EMPTY_OPTIONS = {}.freeze
 
-    if PROCESS_TIME_SUPPORTED
-      def now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    else
-      def now
-        Time.now.to_f
-      end
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     def send_stats(stat, delta, type, opts = EMPTY_OPTIONS)
@@ -400,7 +404,7 @@ module Datadog
 
       sample_rate = opts[:sample_rate] || @sample_rate || 1
 
-      if sample_rate == 1 || rand <= sample_rate
+      if sample_rate == 1 || opts[:pre_sampled] || rand <= sample_rate
         full_stat = serializer.to_stat(stat, delta, type, tags: opts[:tags], sample_rate: sample_rate)
 
         forwarder.send_message(full_stat)

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: dogstatsd-ruby
 version: !ruby/object:Gem::Version
-  version: 5.3.1
+  version: 5.4.0
 platform: ruby
 authors:
 - Rein Henrichs
 - Karim Bogtob
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-21 00:00:00.000000000 Z
+date: 2022-03-01 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby DogStatsd client
 email: code@datadoghq.com
@@ -23,6 +23,7 @@ files:
 - README.md
 - lib/datadog/statsd.rb
 - lib/datadog/statsd/connection.rb
+- lib/datadog/statsd/connection_cfg.rb
 - lib/datadog/statsd/forwarder.rb
 - lib/datadog/statsd/message_buffer.rb
 - lib/datadog/statsd/sender.rb
@@ -34,7 +35,7 @@ files:
 - lib/datadog/statsd/serialization/tag_serializer.rb
 - lib/datadog/statsd/single_thread_sender.rb
 - lib/datadog/statsd/telemetry.rb
-- lib/datadog/statsd/threaded_sender.rb
+- lib/datadog/statsd/timer.rb
 - lib/datadog/statsd/udp_connection.rb
 - lib/datadog/statsd/uds_connection.rb
 - lib/datadog/statsd/version.rb
@@ -43,10 +44,14 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/DataDog/dogstatsd-ruby/issues
-  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v5.3.1/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/5.3.1
-  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v5.3.1
-post_install_message:
+  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v5.4.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/5.4.0
+  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v5.4.0
+post_install_message: |2+
+
+  If you are upgrading from v4.x of the dogstatsd-ruby library, note the major change to the threading model:
+  https://github.com/DataDog/dogstatsd-ruby#migrating-from-v4x-to-v5x
+
 rdoc_options: []
 require_paths:
 - lib
@@ -54,16 +59,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.10
-signing_key:
+rubygems_version: 3.2.22
+signing_key: 
 specification_version: 4
 summary: A Ruby DogStatsd client
 test_files: []

data/lib/datadog/statsd/threaded_sender.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  class FlushQueue < Queue
-  end
-  class CloseQueue < Queue
-  end
-  class Statsd
-    # Sender is using a background thread to flush and pack messages
-    # in a `MessageBuffer`.
-    # The communication with this thread is done using a `Queue`.
-    # If the thread is dead, it is starting a new one to avoid having a blocked
-    # Sender with no background thread to communicate with (most of the time,
-    # having a dead background thread means that a fork just happened and that we
-    # are running in the child process).
-    class Sender
-      CLOSEABLE_QUEUES = Queue.instance_methods.include?(:close)
-
-      def initialize(message_buffer, logger: nil)
-        @message_buffer = message_buffer
-        @logger = logger
-
-        # communication and synchronization with the background thread
-        # @mux is also used to not having multiple threads fighting for
-        # closing the Sender or creating a new background thread
-        @channel = Queue.new
-        @mux = Mutex.new
-
-        @is_closed = false
-
-        # start background thread immediately
-        @sender_thread = Thread.new(&method(:send_loop))
-      end
-
-      def flush(sync: false)
-        @mux.synchronize {
-          # we don't want to send a flush action to the bg thread if:
-          # - there is no bg thread running
-          # - the sender has been closed
-          return if !sender_thread.alive? || @is_closed
-
-          if sync
-             # blocking flush
-             blocking_queue = FlushQueue.new
-             channel << blocking_queue
-             blocking_queue.pop # wait for the bg thread to finish its work
-             blocking_queue.close if CLOSEABLE_QUEUES
-           else
-             # asynchronous flush
-             channel << :flush
-           end
-         }
-      end
-
-      def add(message)
-        return if @is_closed # don't send a message to the bg thread if the sender has been closed
-
-        # the bg thread is not running anymore, this is happening if the main process has forked and
-        # we are running in the child, we will spawn a bg thread and reset buffers (containing parents' messages)
-        if !sender_thread.alive?
-          @mux.synchronize {
-            return if @is_closed
-            # test if a call from another thread has already re-created
-            # the background thread before this one acquired the lock
-            break if sender_thread.alive?
-
-            # re-create the channel of communication since we will spawn a new bg thread
-            channel.close if CLOSEABLE_QUEUES
-            @channel = Queue.new
-            message_buffer.reset # don't use messages appended by another fork
-            @sender_thread = Thread.new(&method(:send_loop))
-          }
-        end
-
-        channel << message
-      end
-
-      # Compatibility with `Sender`
-      def start()
-      end
-
-      def stop()
-        return if @is_closed
-        # use this lock to both: not having another thread stopping this instance nor
-        # having a #add call creating a new thread
-        @mux.synchronize {
-          @is_closed = true
-          if sender_thread.alive? # no reasons to stop the bg thread is none is running already
-            blocking_queue = CloseQueue.new
-            channel << blocking_queue
-            blocking_queue.pop # wait for the bg thread to finish its work
-            blocking_queue.close if CLOSEABLE_QUEUES
-            sender_thread.join(3) # wait for completion, timeout after 3 seconds
-            # TODO(remy): should I close `channel` here?
-          end
-        }
-      end
-
-      private
-
-      attr_reader :message_buffer
-      attr_reader :channel
-      attr_reader :mux
-      attr_reader :sender_thread
-
-      def send_loop
-        until (message = channel.pop).nil? && (CLOSEABLE_QUEUES && channel.closed?)
-          # skip if message is nil, e.g. when the channel is empty and closed
-          next unless message
-
-          case message
-          # if a FlushQueue is received, the background thread has to flush the message
-          # buffer and to send an :unblock to let the caller know that it has finished
-          when FlushQueue
-            message_buffer.flush
-            message << :unblock
-          # if a :flush is received, the background thread has to flush asynchronously
-          when :flush
-            message_buffer.flush
-          # if a CloseQueue is received, the background thread has to do a last flush
-          # and to send an :unblock to let the caller know that it has finished
-          when CloseQueue
-            message << :unblock
-            return
-          else
-            message_buffer.add(message)
-          end
-        end
-      end
-    end
-  end
-end