dogstatsd-ruby 4.4.0 → 4.8.1

data/lib/datadog/statsd/batch.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    class Batch
+      def initialize(connection, max_buffer_bytes)
+        @connection = connection
+        @max_buffer_bytes = max_buffer_bytes
+        @depth = 0
+        reset
+      end
+
+      def open
+        @depth += 1
+
+        yield
+      ensure
+        @depth -= 1
+        flush if !open?
+      end
+
+      def open?
+        @depth > 0
+      end
+
+      def add(message)
+        message_bytes = message.bytesize
+
+        unless @buffer_bytes == 0
+          if @buffer_bytes + 1 + message_bytes >= @max_buffer_bytes
+            flush
+          else
+            @buffer << "\n"
+            @buffer_bytes += 1
+          end
+        end
+
+        @buffer << message
+        @buffer_bytes += message_bytes
+      end
+
+      def flush
+        return if @buffer_bytes == 0
+        @connection.write(@buffer)
+        reset
+      end
+
+      private
+
+      def reset
+        @buffer = String.new
+        @buffer_bytes = 0
+      end
+    end
+  end
+end

data/lib/datadog/statsd/connection.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    class Connection
+      def initialize(telemetry)
+        @telemetry = telemetry
+      end
+
+      # Close the underlying socket
+      def close
+        begin
+          @socket && @socket.close if instance_variable_defined?(:@socket)
+        rescue StandardError => boom
+          logger.error { "Statsd: #{boom.class} #{boom}" } if logger
+        end
+        @socket = nil
+      end
+
+      def write(payload)
+        logger.debug { "Statsd: #{payload}" } if logger
+
+        flush_telemetry = telemetry.flush?
+
+        payload += telemetry.flush if flush_telemetry
+
+        send_message(payload)
+
+        telemetry.reset if flush_telemetry
+
+        telemetry.sent(packets: 1, bytes: payload.length)
+      rescue StandardError => boom
+        # Try once to reconnect if the socket has been closed
+        retries ||= 1
+        if retries <= 1 &&
+          (boom.is_a?(Errno::ENOTCONN) or
+           boom.is_a?(Errno::ECONNREFUSED) or
+           boom.is_a?(IOError) && boom.message =~ /closed stream/i)
+          retries += 1
+          begin
+            close
+            retry
+          rescue StandardError => e
+            boom = e
+          end
+        end
+
+        telemetry.dropped(packets: 1, bytes: payload.length)
+        logger.error { "Statsd: #{boom.class} #{boom}" } if logger
+        nil
+      end
+
+      private
+      attr_reader :telemetry
+      attr_reader :logger
+
+      def socket
+        @socket ||= connect
+      end
+    end
+  end
+end

data/lib/datadog/statsd/serialization.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+    end
+  end
+end
+
+require_relative 'serialization/tag_serializer'
+require_relative 'serialization/service_check_serializer'
+require_relative 'serialization/event_serializer'
+require_relative 'serialization/stat_serializer'
+
+require_relative 'serialization/serializer'

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+      class EventSerializer
+        EVENT_BASIC_OPTIONS = {
+          date_happened:    'd:',
+          hostname:         'h:',
+          aggregation_key:  'k:',
+          priority:         'p:',
+          source_type_name: 's:',
+          alert_type:       't:',
+        }.freeze
+
+        def initialize(global_tags: [])
+          @tag_serializer = TagSerializer.new(global_tags)
+        end
+
+        def format(title, text, options = EMPTY_OPTIONS)
+          title = escape(title)
+          text = escape(text)
+
+          String.new.tap do |event|
+            event << '_e{'
+            event << title.bytesize.to_s
+            event << ','
+            event << text.bytesize.to_s
+            event << '}:'
+            event << title
+            event << '|'
+            event << text
+
+            # we are serializing the generic service check options
+            # before serializing specialized options that need edge-cases
+            EVENT_BASIC_OPTIONS.each do |option_key, shortcut|
+              if value = options[option_key]
+                event << '|'
+                event << shortcut
+                event << value.to_s.delete('|')
+              end
+            end
+
+            # also returns the global tags from serializer
+            if tags = tag_serializer.format(options[:tags])
+              event << '|#'
+              event << tags
+            end
+
+            if event.bytesize > MAX_EVENT_SIZE
+              raise "Event #{title} payload is too big (more that 8KB), event discarded"
+            end
+          end
+        end
+
+        protected
+        attr_reader :tag_serializer
+
+        def escape(text)
+          text.delete('|').tap do |t|
+            t.gsub!("\n", '\n')
+          end
+        end
+      end
+    end
+  end
+end

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,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  class Statsd
+    module Serialization
+      class StatSerializer
+        def initialize(prefix, global_tags: [])
+          @prefix = prefix
+          @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
+
+            # tags
+            if tags_list = tag_serializer.format(tags)
+              stat << '|'
+              stat << '#'
+              stat << tags_list
+            end
+          end
+        end
+
+        def global_tags
+          tag_serializer.global_tags
+        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!(':|@', '_')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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)
+        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
+
+          tag_list.join(',') if tag_list.any?
+        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.each_with_object([]) do |tag_pair, formatted_tags|
+              if tag_pair.last.nil?
+                formatted_tags << "#{tag_pair.first}"
+              else
+                formatted_tags << "#{tag_pair.first}:#{tag_pair.last}"
+              end
+            end
+          when Array
+            tags.dup
+          else
+            []
+          end.map! do |tag|
+            escape_tag_content(tag)
+          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