dogstatsd-ruby 4.8.1 → 5.6.1

data/lib/datadog/statsd/sender.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    # Sender is using a companion 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 companion thread to communicate with (most of the time, having
+    # a dead companion 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, 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
+        @flush_timer = if flush_interval
+          Datadog::Statsd::Timer.new(flush_interval) { flush(sync: true) }
+        else
+          nil
+        end
+      end
+
+      def flush(sync: false)
+        # keep a copy around in case another thread is calling #stop while this method is running
+        current_message_queue = message_queue
+
+        # don't try to flush if there is no message_queue instantiated or
+        # no companion thread running
+        if !current_message_queue
+          @logger.debug { "Statsd: can't flush: no message queue ready" } if @logger
+          return
+        end
+        if !sender_thread.alive?
+          @logger.debug { "Statsd: can't flush: no sender_thread alive" } if @logger
+          return
+        end
+
+        current_message_queue.push(:flush)
+        rendez_vous if sync
+      end
+
+      def rendez_vous
+        # could happen if #start hasn't be called
+        return unless message_queue
+
+        # Initialize and get the thread's sync queue
+        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)
+        # wait for the sender thread to send a message
+        # once the flush is done
+        queue.pop
+      end
+
+      def add(message)
+        raise ArgumentError, 'Start sender first' unless message_queue
+
+        # if the thread does not exist, we assume we are running in a forked process,
+        # empty the message queue and message buffers (these messages belong to
+        # the parent process) and spawn a new companion thread.
+        if !sender_thread.alive?
+          @mx.synchronize {
+            # a call from another thread has already re-created
+            # the companion thread before this one acquired the lock
+            break if sender_thread.alive?
+            @logger.debug { "Statsd: companion thread is dead, re-creating one" } if @logger
+
+            message_queue.close if CLOSEABLE_QUEUES
+            @message_queue = nil
+            message_buffer.reset
+            start
+            @flush_timer.start if @flush_timer && @flush_timer.stop?
+          }
+        end
+
+        if message_queue.length <= @queue_size
+          message_queue << message
+        else
+          if @telemetry
+            bytesize = message.respond_to?(:bytesize) ? message.bytesize : 0
+            @telemetry.dropped_queue(packets: 1, bytes: bytesize)
+          end
+        end
+      end
+
+      def start
+        raise ArgumentError, 'Sender already started' if message_queue
+
+        # initialize a new message queue for the background thread
+        @message_queue = @queue_class.new
+        # start background thread
+        @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
+        # when calling stop, make sure that no other threads is trying
+        # to close the sender nor trying to continue to `#add` more message
+        # into the sender.
+        def stop(join_worker: true)
+          @flush_timer.stop if @flush_timer
+
+          message_queue = @message_queue
+          message_queue.close if message_queue
+
+          sender_thread = @sender_thread
+          sender_thread.join if sender_thread && join_worker
+        end
+      else
+        # when calling stop, make sure that no other threads is trying
+        # to close the sender nor trying to continue to `#add` more message
+        # into the sender.
+        def stop(join_worker: true)
+          @flush_timer.stop if @flush_timer
+
+          message_queue = @message_queue
+          message_queue << :close if message_queue
+
+          sender_thread = @sender_thread
+          sender_thread.join if sender_thread && join_worker
+        end
+      end
+
+      private
+
+      attr_reader :message_buffer
+      attr_reader :message_queue
+      attr_reader :sender_thread
+
+      if CLOSEABLE_QUEUES
+        def send_loop
+          until (message = message_queue.pop).nil? && message_queue.closed?
+            # skip if message is nil, e.g. when message_queue
+            # is empty and closed
+            next unless message
+
+            case message
+            when :flush
+              message_buffer.flush
+            when @queue_class
+              message.push(:go_on)
+            else
+              message_buffer.add(message)
+            end
+          end
+
+          @message_queue = nil
+          @sender_thread = nil
+        end
+      else
+        def send_loop
+          loop do
+            message = message_queue.pop
+
+            next unless message
+
+            case message
+            when :close
+              break
+            when :flush
+              message_buffer.flush
+            when @queue_class
+              message.push(:go_on)
+            else
+              message_buffer.add(message)
+            end
+          end
+
+          @message_queue = nil
+          @sender_thread = nil
+        end
+      end
+    end
+  end
+end

data/lib/datadog/statsd/serialization/event_serializer.rb

@@ -48,7 +48,11 @@ module Datadog
             end
 
             if event.bytesize > MAX_EVENT_SIZE
-              raise "Event #{title} payload is too big (more that 8KB), event discarded"
+              if options[:truncate_if_too_long]
+                event.slice!(MAX_EVENT_SIZE..event.length)
+              else
+                raise "Event #{title} payload is too big (more that 8KB), event discarded"
+              end
             end
           end
         end

data/lib/datadog/statsd/serialization/stat_serializer.rb

@@ -6,34 +6,24 @@ module Datadog
       class StatSerializer
         def initialize(prefix, global_tags: [])
           @prefix = prefix
+          @prefix_str = prefix.to_s
           @tag_serializer = TagSerializer.new(global_tags)
         end
 
         def format(name, delta, type, tags: [], sample_rate: 1)
-          String.new.tap do |stat|
-            stat << prefix if prefix
-
-            # stat value
-            stat << formated_name(name)
-            stat << ':'
-            stat << delta.to_s
-
-            # stat type
-            stat << '|'
-            stat << type
-
-            # sample_rate
-            if sample_rate != 1
-              stat << '|'
-              stat << '@'
-              stat << sample_rate.to_s
-            end
+          name = formated_name(name)
 
-            # tags
+          if sample_rate != 1
+            if tags_list = tag_serializer.format(tags)
+              "#{@prefix_str}#{name}:#{delta}|#{type}|@#{sample_rate}|##{tags_list}"
+            else
+              "#{@prefix_str}#{name}:#{delta}|#{type}|@#{sample_rate}"
+            end
+          else
             if tags_list = tag_serializer.format(tags)
-              stat << '|'
-              stat << '#'
-              stat << tags_list
+              "#{@prefix_str}#{name}:#{delta}|#{type}|##{tags_list}"
+            else
+              "#{@prefix_str}#{name}:#{delta}|#{type}"
             end
           end
         end
@@ -43,18 +33,21 @@ module Datadog
         end
 
         private
+
         attr_reader :prefix
         attr_reader :tag_serializer
 
         def formated_name(name)
-          formated = name.is_a?(String) ? name.dup : name.to_s
-
-          formated.tap do |f|
-            # replace Ruby module scoping with '.'
-            f.gsub!('::', '.')
-            # replace reserved chars (: | @) with underscores.
-            f.tr!(':|@', '_')
+          if name.is_a?(String)
+            # DEV: gsub is faster than dup.gsub!
+            formated = name.gsub('::', '.')
+          else
+            formated = name.to_s
+            formated.gsub!('::', '.')
           end
+
+          formated.tr!(':|@', '_')
+          formated
         end
       end
     end

data/lib/datadog/statsd/serialization/tag_serializer.rb

@@ -13,18 +13,25 @@ module Datadog
 
           # Convert to tag list and set
           @global_tags = to_tags_list(global_tags)
+          if @global_tags.any?
+            @global_tags_formatted = @global_tags.join(',')
+          else
+            @global_tags_formatted = nil
+          end
         end
 
         def format(message_tags)
-          # fast return global tags if there's no message_tags
-          # to avoid more allocations
-          tag_list =  if message_tags && message_tags.any?
-                        global_tags + to_tags_list(message_tags)
-                      else
-                        global_tags
-                      end
+          if !message_tags || message_tags.empty?
+            return @global_tags_formatted
+          end
 
-          tag_list.join(',') if tag_list.any?
+          tags = if @global_tags_formatted
+                   [@global_tags_formatted, to_tags_list(message_tags)]
+                 else
+                   to_tags_list(message_tags)
+                 end
+
+          tags.join(',')
         end
 
         attr_reader :global_tags
@@ -51,19 +58,17 @@ module Datadog
         def to_tags_list(tags)
           case tags
           when Hash
-            tags.each_with_object([]) do |tag_pair, formatted_tags|
-              if tag_pair.last.nil?
-                formatted_tags << "#{tag_pair.first}"
+            tags.map do |name, value|
+              if value
+                escape_tag_content("#{name}:#{value}")
               else
-                formatted_tags << "#{tag_pair.first}:#{tag_pair.last}"
+                escape_tag_content(name)
               end
             end
           when Array
-            tags.dup
+            tags.map { |tag| escape_tag_content(tag) }
           else
             []
-          end.map! do |tag|
-            escape_tag_content(tag)
           end
         end
 

data/lib/datadog/statsd/single_thread_sender.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    # The SingleThreadSender is a sender synchronously buffering messages
+    # in a `MessageBuffer`.
+    # 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, flush_interval: nil, queue_size: 1)
+        @message_buffer = message_buffer
+        @logger = logger
+        @mx = Mutex.new
+        @message_queue_size = queue_size
+        @message_queue = []
+        @flush_timer = if flush_interval
+          Datadog::Statsd::Timer.new(flush_interval) { flush }
+        else
+          nil
+        end
+        # store the pid for which this sender has been created
+        update_fork_pid
+      end
+
+      def add(message)
+        @mx.synchronize {
+          # we have just forked, meaning we have messages in the buffer that we should
+          # not send, they belong to the parent process, let's clear the buffer.
+          if forked?
+            @message_buffer.reset
+            @message_queue.clear
+            @flush_timer.start if @flush_timer && @flush_timer.stop?
+            update_fork_pid
+          end
+
+          @message_queue << message
+          if @message_queue.size >= @message_queue_size
+            drain_message_queue
+          end
+        }
+      end
+
+      def flush(*)
+        @mx.synchronize {
+          drain_message_queue
+          @message_buffer.flush()
+        }
+      end
+
+      def start()
+        @flush_timer.start if @flush_timer
+      end
+
+      def stop()
+        @flush_timer.stop if @flush_timer
+      end
+
+      # Compatibility with `Sender`
+      def rendez_vous()
+      end
+
+      private
+
+      def drain_message_queue
+        while msg = @message_queue.shift
+          @message_buffer.add(msg)
+        end
+      end
+
+      # below are "fork management" methods to be able to clean the MessageBuffer
+      # if it detects that it is running in a unknown PID.
+
+      def forked?
+        Process.pid != @fork_pid
+      end
+
+      def update_fork_pid
+        @fork_pid = Process.pid
+      end
+    end
+  end
+end

data/lib/datadog/statsd/telemetry.rb

@@ -9,12 +9,17 @@ 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 :estimate_max_size
+      attr_reader :packets_dropped_queue
+      attr_reader :packets_dropped_writer
 
-      def initialize(disabled, flush_interval, global_tags: [], transport_type: :udp)
-        @disabled = disabled
+      # Rough estimation of maximum telemetry message size without tags
+      MAX_TELEMETRY_MESSAGE_SIZE_WT_TAGS = 50 # bytes
+
+      def initialize(flush_interval, global_tags: [], transport_type: :udp)
         @flush_interval = flush_interval
         @global_tags = global_tags
         @transport_type = transport_type
@@ -27,15 +32,10 @@ module Datadog
           client_version: VERSION,
           client_transport: transport_type,
         ).format(global_tags)
+      end
 
-        # estimate_max_size is an estimation or the maximum size of the
-        # telemetry payload. Since we don't want our packet to go over
-        # 'max_buffer_bytes', we have to adjust with the size of the telemetry
-        # (and any tags used). The telemetry payload size will change depending
-        # on the actual value of metrics: metrics received, packet dropped,
-        # etc. This is why we add a 63bytes margin: 9 bytes for each of the 7
-        # telemetry metrics.
-        @estimate_max_size = disabled ? 0 : flush.length + 9 * 7
+      def would_fit_in?(max_buffer_payload_size)
+        MAX_TELEMETRY_MESSAGE_SIZE_WT_TAGS + serialized_tags.size < max_buffer_payload_size
       end
 
       def reset
@@ -44,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
 
@@ -58,32 +62,47 @@ 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 flush?
+      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?
         @next_flush_time < now_in_s
       end
 
       def flush
-        return '' if @disabled
-
-        # using shorthand syntax to reduce the garbage collection
-        %Q(
-datadog.dogstatsd.client.metrics:#{@metrics}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.events:#{@events}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.service_checks:#{@service_checks}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.bytes_sent:#{@bytes_sent}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.bytes_dropped:#{@bytes_dropped}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.packets_sent:#{@packets_sent}|#{COUNTER_TYPE}|##{serialized_tags}
-datadog.dogstatsd.client.packets_dropped:#{@packets_dropped}|#{COUNTER_TYPE}|##{serialized_tags})
+        [
+          sprintf(pattern, 'metrics', @metrics),
+          sprintf(pattern, 'events', @events),
+          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
 
       private
       attr_reader :serialized_tags
 
+      def pattern
+        @pattern ||= "datadog.dogstatsd.client.%s:%d|#{COUNTER_TYPE}|##{serialized_tags}"
+      end
+
       if Kernel.const_defined?('Process') && Process.respond_to?(:clock_gettime)
         def now_in_s
           Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)

data/lib/datadog/statsd/timer.rb

@@ -0,0 +1,61 @@
+# 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
+        @thread = nil
+      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,32 +5,43 @@ 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, logger, telemetry)
-        super(telemetry)
-        @host = host || ENV.fetch('DD_AGENT_HOST', DEFAULT_HOST)
-        @port = port || ENV.fetch('DD_DOGSTATSD_PORT', DEFAULT_PORT).to_i
-        @logger = logger
+      def initialize(host, port, **kwargs)
+        super(**kwargs)
+
+        @host = host
+        @port = port
+        @socket = nil
+      end
+
+      def close
+        @socket.close if @socket
+        @socket = nil
       end
 
       private
 
       def connect
-        UDPSocket.new.tap do |socket|
-          socket.connect(host, port)
-        end
+        close if @socket
+
+        family = Addrinfo.udp(host, port).afamily
+
+        @socket = UDPSocket.new(family)
+        @socket.connect(host, port)
       end
 
+      # send_message is writing the message in the socket, it may create the socket if nil
+      # It is not thread-safe but since it is called by either the Sender bg thread or the
+      # SingleThreadSender (which is using a mutex while Flushing), only one thread must call
+      # it at a time.
       def send_message(message)
-        socket.send(message, 0)
+        connect unless @socket
+        @socket.send(message, 0)
       end
     end
   end

data/lib/datadog/statsd/uds_connection.rb

@@ -10,24 +10,35 @@ module Datadog
       # DogStatsd unix socket path
       attr_reader :socket_path
 
-      def initialize(socket_path, logger, telemetry)
-        super(telemetry)
+      def initialize(socket_path, **kwargs)
+        super(**kwargs)
+
         @socket_path = socket_path
-        @logger = logger
+        @socket = nil
+      end
+
+      def close
+        @socket.close if @socket
+        @socket = nil
       end
 
       private
 
       def connect
-        socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM)
-        socket.connect(Socket.pack_sockaddr_un(@socket_path))
-        socket
+        close if @socket
+
+        @socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM)
+        @socket.connect(Socket.pack_sockaddr_un(@socket_path))
       end
 
+      # send_message is writing the message in the socket, it may create the socket if nil
+      # It is not thread-safe but since it is called by either the Sender bg thread or the
+      # SingleThreadSender (which is using a mutex while Flushing), only one thread must call
+      # it at a time.
       def send_message(message)
-        socket.sendmsg_nonblock(message)
+        connect unless @socket
+        @socket.sendmsg_nonblock(message)
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ENOENT => e
-        @socket = nil
         # TODO: FIXME: This error should be considered as a retryable error in the
         # Connection class. An even better solution would be to make BadSocketError inherit
         # from a specific retryable error class in the Connection class.