dogstatsd-ruby 4.7.0 → 5.0.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,92 @@
+# 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)
+          @global_tags_formatted = @global_tags.join(',') if @global_tags.any?
+        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/telemetry.rb

@@ -4,29 +4,34 @@ require 'time'
 module Datadog
   class Statsd
     class Telemetry
-      attr_accessor :metrics
-      attr_accessor :events
-      attr_accessor :service_checks
-      attr_accessor :bytes_sent
-      attr_accessor :bytes_dropped
-      attr_accessor :packets_sent
-      attr_accessor :packets_dropped
-      attr_reader   :estimate_max_size
+      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
 
-      def initialize(disabled, tags, flush_interval)
-        @disabled = disabled
-        @tags = tags
+      # 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
 
-        # 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
+        # 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
@@ -37,28 +42,54 @@ module Datadog
         @bytes_dropped = 0
         @packets_sent = 0
         @packets_dropped = 0
-        @next_flush_time = Time.now.to_i + @flush_interval
+        @next_flush_time = now_in_s + @flush_interval
       end
 
-      def flush?
-        if @next_flush_time < Time.now.to_i
-          return true
-        end
-        return false
+      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
-        return '' if @disabled
+        [
+          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
 
-        # using shorthand syntax to reduce the garbage collection
-        return %Q(
-datadog.dogstatsd.client.metrics:#{@metrics}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.events:#{@events}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.service_checks:#{@service_checks}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.bytes_sent:#{@bytes_sent}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.bytes_dropped:#{@bytes_dropped}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.packets_sent:#{@packets_sent}|#{COUNTER_TYPE}|##{@tags}
-datadog.dogstatsd.client.packets_dropped:#{@packets_dropped}|#{COUNTER_TYPE}|##{@tags})
+      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

data/lib/datadog/statsd/udp_connection.rb

@@ -14,11 +14,11 @@ module Datadog
       # StatsD port. Defaults to 8125.
       attr_reader :port
 
-      def initialize(host, port, logger, telemetry)
-        super(telemetry)
+      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)
-        @logger = logger
+        @port = port || ENV.fetch('DD_DOGSTATSD_PORT', DEFAULT_PORT).to_i
       end
 
       private

data/lib/datadog/statsd/uds_connection.rb

@@ -10,10 +10,10 @@ 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
       end
 
       private
@@ -28,6 +28,9 @@ module Datadog
         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

data/lib/datadog/statsd/version.rb

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

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: dogstatsd-ruby
 version: !ruby/object:Gem::Version
-  version: 4.7.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Rein Henrichs
-autorequire: 
+- Karim Bogtob
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-14 00:00:00.000000000 Z
+date: 2021-04-07 00:00:00.000000000 Z
 dependencies: []
-description: A Ruby DogStastd client
+description: A Ruby DogStatsd client
 email: code@datadoghq.com
 executables: []
 extensions: []
@@ -21,20 +22,29 @@ files:
 - LICENSE.txt
 - README.md
 - lib/datadog/statsd.rb
-- lib/datadog/statsd/batch.rb
 - lib/datadog/statsd/connection.rb
+- lib/datadog/statsd/forwarder.rb
+- lib/datadog/statsd/message_buffer.rb
+- lib/datadog/statsd/sender.rb
+- lib/datadog/statsd/serialization.rb
+- lib/datadog/statsd/serialization/event_serializer.rb
+- lib/datadog/statsd/serialization/serializer.rb
+- lib/datadog/statsd/serialization/service_check_serializer.rb
+- lib/datadog/statsd/serialization/stat_serializer.rb
+- lib/datadog/statsd/serialization/tag_serializer.rb
 - lib/datadog/statsd/telemetry.rb
 - lib/datadog/statsd/udp_connection.rb
 - lib/datadog/statsd/uds_connection.rb
+- lib/datadog/statsd/version.rb
 homepage: https://github.com/DataDog/dogstatsd-ruby
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/DataDog/dogstatsd-ruby/issues
-  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v4.7.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/4.7.0
-  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v4.7.0
-post_install_message: 
+  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v5.0.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/5.0.0
+  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v5.0.0
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -49,9 +59,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 2.7.10
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A Ruby DogStatsd client
 test_files: []