dogstatsd-ruby 4.0.0 → 5.2.0

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# require 'forwardable'
+
+module Datadog
+  class Statsd
+    module Serialization
+      class Serializer
+        def initialize(prefix: nil, global_tags: [])
+          @stat_serializer = StatSerializer.new(prefix, global_tags: global_tags)
+          @service_check_serializer = ServiceCheckSerializer.new(global_tags: global_tags)
+          @event_serializer = EventSerializer.new(global_tags: global_tags)
+        end
+
+        # using *args would make new allocations
+        def to_stat(name, delta, type, tags: [], sample_rate: 1)
+          stat_serializer.format(name, delta, type, tags: tags, sample_rate: sample_rate)
+        end
+
+        # using *args would make new allocations
+        def to_service_check(name, status, options = EMPTY_OPTIONS)
+          service_check_serializer.format(name, status, options)
+        end
+
+        # using *args would make new allocations
+        def to_event(title, text, options = EMPTY_OPTIONS)
+          event_serializer.format(title, text, options)
+        end
+
+        def global_tags
+          stat_serializer.global_tags
+        end
+
+        protected
+        attr_reader :stat_serializer
+        attr_reader :service_check_serializer
+        attr_reader :event_serializer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+      class ServiceCheckSerializer
+        SERVICE_CHECK_BASIC_OPTIONS = {
+          timestamp: 'd:',
+          hostname:  'h:',
+        }.freeze
+
+        def initialize(global_tags: [])
+          @tag_serializer = TagSerializer.new(global_tags)
+        end
+
+        def format(name, status, options = EMPTY_OPTIONS)
+          String.new.tap do |service_check|
+            # line basics
+            service_check << "_sc"
+            service_check << "|"
+            service_check << name.to_s
+            service_check << "|"
+            service_check << status.to_s
+
+            # we are serializing the generic service check options
+            # before serializing specialized options that need edge-cases
+            SERVICE_CHECK_BASIC_OPTIONS.each do |option_key, shortcut|
+              if value = options[option_key]
+                service_check << '|'
+                service_check << shortcut
+                service_check << value.to_s.delete('|')
+              end
+            end
+
+            if message = options[:message]
+              service_check << '|m:'
+              service_check << escape_message(message)
+            end
+
+            # also returns the global tags from serializer
+            if tags = tag_serializer.format(options[:tags])
+              service_check << '|#'
+              service_check << tags
+            end
+          end
+        end
+
+        protected
+        attr_reader :tag_serializer
+
+        def escape_message(message)
+          message.delete('|').tap do |m|
+            m.gsub!("\n", '\n')
+            m.gsub!('m:', 'm\:')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+      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)
+          name = formated_name(name)
+
+          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)
+              "#{@prefix_str}#{name}:#{delta}|#{type}|##{tags_list}"
+            else
+              "#{@prefix_str}#{name}:#{delta}|#{type}"
+            end
+          end
+        end
+
+        def global_tags
+          tag_serializer.global_tags
+        end
+
+        private
+
+        attr_reader :prefix
+        attr_reader :tag_serializer
+
+        def formated_name(name)
+          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
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+      class TagSerializer
+        def initialize(global_tags = [], env = ENV)
+          # Convert to hash
+          global_tags = to_tags_hash(global_tags)
+
+          # Merge with default tags
+          global_tags = default_tags(env).merge(global_tags)
+
+          # 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)
+          if !message_tags || message_tags.empty?
+            return @global_tags_formatted
+          end
+
+          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
+
+        private
+
+        def to_tags_hash(tags)
+          case tags
+          when Hash
+            tags.dup
+          when Array
+            Hash[
+              tags.map do |string|
+                tokens = string.split(':')
+                tokens << nil if tokens.length == 1
+                tokens.length == 2 ? tokens : nil
+              end.compact
+            ]
+          else
+            {}
+          end
+        end
+
+        def to_tags_list(tags)
+          case tags
+          when Hash
+            tags.map do |name, value|
+              if value
+                escape_tag_content("#{name}:#{value}")
+              else
+                escape_tag_content(name)
+              end
+            end
+          when Array
+            tags.map { |tag| escape_tag_content(tag) }
+          else
+            []
+          end
+        end
+
+        def escape_tag_content(tag)
+          tag.to_s.delete('|,')
+        end
+
+        def dd_tags(env = ENV)
+          return {} unless dd_tags = env['DD_TAGS']
+
+          to_tags_hash(dd_tags.split(','))
+        end
+
+        def default_tags(env = ENV)
+          dd_tags(env).tap do |tags|
+            tags['dd.internal.entity_id'] = env['DD_ENTITY_ID'] if env.key?('DD_ENTITY_ID')
+            tags['env'] = env['DD_ENV'] if env.key?('DD_ENV')
+            tags['service'] = env['DD_SERVICE'] if env.key?('DD_SERVICE')
+            tags['version'] = env['DD_VERSION'] if env.key?('DD_VERSION')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/statsd/single_thread_sender.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    class SingleThreadSender
+      def initialize(message_buffer)
+        @message_buffer = message_buffer
+      end
+
+      def add(message)
+        @message_buffer.add(message)
+      end
+
+      def flush(*)
+        @message_buffer.flush()
+      end
+
+      # Compatibility with `Sender`
+      def start()
+      end
+
+      # Compatibility with `Sender`
+      def stop()
+      end
+
+      # Compatibility with `Sender`
+      def rendez_vous()
+      end
+    end
+  end
+end

data/lib/datadog/statsd/telemetry.rb

@@ -0,0 +1,96 @@
+# 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 :packets_sent
+      attr_reader :packets_dropped
+
+      # 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
+        @packets_sent = 0
+        @packets_dropped = 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(bytes: 0, packets: 0)
+        @bytes_dropped += bytes
+        @packets_dropped += 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, 'packets_sent', @packets_sent),
+          sprintf(pattern, 'packets_dropped', @packets_dropped),
+        ]
+      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/udp_connection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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.
+      attr_reader :host
+
+      # StatsD port. Defaults to 8125.
+      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
+      end
+
+      private
+
+      def connect
+        UDPSocket.new.tap do |socket|
+          socket.connect(host, port)
+        end
+      end
+
+      def send_message(message)
+        socket.send(message, 0)
+      end
+    end
+  end
+end

data/lib/datadog/statsd/uds_connection.rb

@@ -0,0 +1,38 @@
+# 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
+      end
+
+      private
+
+      def connect
+        socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM)
+        socket.connect(Socket.pack_sockaddr_un(@socket_path))
+        socket
+      end
+
+      def send_message(message)
+        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.
+        raise BadSocketError, "#{e.class}: #{e}"
+      end
+    end
+  end
+end