dogstatsd-ruby 3.3.0 → 5.6.1

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+require 'time'
+
+module Datadog
+  class Statsd
+    class Telemetry
+      attr_reader :metrics
+      attr_reader :events
+      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
+
+      def initialize(flush_interval, global_tags: [], transport_type: :udp)
+        @flush_interval = flush_interval
+        @global_tags = global_tags
+        @transport_type = transport_type
+        reset
+
+        # TODO: Karim: I don't know why but telemetry tags are serialized
+        # before global tags so by refactoring this, I am keeping the same behavior
+        @serialized_tags = Serialization::TagSerializer.new(
+          client: 'ruby',
+          client_version: VERSION,
+          client_transport: transport_type,
+        ).format(global_tags)
+      end
+
+      def would_fit_in?(max_buffer_payload_size)
+        MAX_TELEMETRY_MESSAGE_SIZE_WT_TAGS + serialized_tags.size < max_buffer_payload_size
+      end
+
+      def reset
+        @metrics = 0
+        @events = 0
+        @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
+
+      def sent(metrics: 0, events: 0, service_checks: 0, bytes: 0, packets: 0)
+        @metrics += metrics
+        @events += events
+        @service_checks += service_checks
+
+        @bytes_sent += bytes
+        @packets_sent += packets
+      end
+
+      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?
+        @next_flush_time < now_in_s
+      end
+
+      def flush
+        [
+          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)
+        end
+      else
+        def now_in_s
+          Time.now.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'connection'
+
+module Datadog
+  class Statsd
+    class UDPConnection < Connection
+      # StatsD host.
+      attr_reader :host
+
+      # StatsD port.
+      attr_reader :port
+
+      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
+        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)
+        connect unless @socket
+        @socket.send(message, 0)
+      end
+    end
+  end
+end

data/lib/datadog/statsd/uds_connection.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'connection'
+
+module Datadog
+  class Statsd
+    class UDSConnection < Connection
+      class BadSocketError < StandardError; end
+
+      # DogStatsd unix socket path
+      attr_reader :socket_path
+
+      def initialize(socket_path, **kwargs)
+        super(**kwargs)
+
+        @socket_path = socket_path
+        @socket = nil
+      end
+
+      def close
+        @socket.close if @socket
+        @socket = nil
+      end
+
+      private
+
+      def connect
+        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)
+        connect unless @socket
+        @socket.sendmsg_nonblock(message)
+      rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ENOENT => e
+        # 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.
+        raise BadSocketError, "#{e.class}: #{e}"
+      end
+    end
+  end
+end

data/lib/datadog/statsd/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'connection'
+
+module Datadog
+  class Statsd
+    VERSION = '5.6.1'
+  end
+end