dogstatsd-ruby 4.7.0 → 4.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57d7660dad73ad8c0c5f37f6d6130474d255beaa467aca03f532e552d0b608e0
-  data.tar.gz: 30c8686d3045e4cfb2ca18c57390f78dbcccba1ff941deb170d89497953d5e84
+  metadata.gz: 7485524dc133a21013d2ab5144511a4ba38740226bdeaf1d3131be99859f33ec
+  data.tar.gz: 6358ca98c85788c904e48ebf3d0d3751372b3ba5baaaf194199fef1f5badbae0
 SHA512:
-  metadata.gz: 99214bb827186d3b01568cc59064f7d2a8d043a4a739c7f90a2b013feeeead11ed363937c37d2c29846d101ed886c318a6369c2d5a57292b0c058db81c708813
-  data.tar.gz: c82e6c5e9668804688fd308e091398e05ada88dac8ea78a678ee2da671eaf297ffd95997efaf376506632f65e88b4096a6a9b2590667f772f19c6b020e238827
+  metadata.gz: edf3b324873893d4acfff6a8775ee7d3ca337e416f283f29137abbaed447f8db220d8d09cc00131a0a53b0d4f38555f48d669658812ebe739903dc68a74ab8c3
+  data.tar.gz: 9b5bd953d65e25ad74733175febb8a4a3b4dfee5e2353d1f539684443ddface8f65c9ebde4f88dfd5bd4063b892c2c76350754a112481bfeacb2f454a199dac9

data/lib/datadog/statsd.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 require 'socket'
 
+require_relative 'statsd/version'
 require_relative 'statsd/telemetry'
 require_relative 'statsd/udp_connection'
 require_relative 'statsd/uds_connection'
 require_relative 'statsd/batch'
+require_relative 'statsd/serialization'
 
 # = Datadog::Statsd: A DogStatsd client (https://www.datadoghq.com)
 #
@@ -24,25 +26,6 @@ require_relative 'statsd/batch'
 #   statsd = Datadog::Statsd.new 'localhost', 8125, tags: 'tag1:true'
 module Datadog
   class Statsd
-    # Create a dictionary to assign a key to every parameter's name, except for tags (treated differently)
-    # Goal: Simple and fast to add some other parameters
-    OPTS_KEYS = {
-      date_happened:    :d,
-      hostname:         :h,
-      aggregation_key:  :k,
-      priority:         :p,
-      source_type_name: :s,
-      alert_type:       :t,
-    }.freeze
-
-    # Service check options
-    SC_OPT_KEYS = {
-      timestamp: 'd:',
-      hostname:  'h:',
-      tags:      '#',
-      message:   'm:',
-    }.freeze
-
     OK       = 0
     WARNING  = 1
     CRITICAL = 2
@@ -59,13 +42,14 @@ module Datadog
     DISTRIBUTION_TYPE = 'd'
     TIMING_TYPE = 'ms'
     SET_TYPE = 's'
-    VERSION = '4.7.0'
 
     # A namespace to prepend to all statsd calls. Defaults to no namespace.
     attr_reader :namespace
 
     # Global tags to be added to every statsd call. Defaults to no tags.
-    attr_reader :tags
+    def tags
+      serializer.global_tags
+    end
 
     # Buffer containing the statsd message before they are sent in batch
     attr_reader :buffer
@@ -103,36 +87,31 @@ module Datadog
         raise ArgumentError, 'tags must be a Array<String> or a Hash'
       end
 
-      tags = tag_hash_to_array(tags) if tags.is_a?(Hash)
-      @tags = (tags || []).compact.map! do |tag|
-        escape_tag_content(tag)
-      end
+      @namespace = namespace
+      @prefix = @namespace ? "#{@namespace}.".freeze : nil
 
-      # append the entity id to tags if DD_ENTITY_ID env var is not nil
-      unless ENV.fetch('DD_ENTITY_ID', nil).nil?
-        dd_entity = escape_tag_content(ENV.fetch('DD_ENTITY_ID', nil))
-        @tags << 'dd.internal.entity_id:' + dd_entity
-      end
+      @serializer = Serialization::Serializer.new(prefix: @prefix, global_tags: tags)
 
-      # init telemetry
-      transport_type = socket_path.nil? ? 'udp': 'uds'
-      telemetry_tags = (["client:ruby", "client_version:#{VERSION}", "client_transport:#{transport_type}"] + @tags).join(COMMA).freeze
-      @telemetry = Telemetry.new(disable_telemetry, telemetry_tags, telemetry_flush_interval)
+      transport_type = socket_path.nil? ? :udp : :uds
 
-      if socket_path.nil?
-        @connection = UDPConnection.new(host, port, logger, @telemetry)
-      else
-        @connection = UDSConnection.new(socket_path, logger, @telemetry)
-      end
-      @logger = logger
+      @telemetry = Telemetry.new(disable_telemetry, telemetry_flush_interval,
+        global_tags: tags,
+        transport_type: transport_type
+      )
 
-      @namespace = namespace
-      @prefix = @namespace ? "#{@namespace}.".freeze : nil
+      @connection = case transport_type
+                    when :udp
+                      UDPConnection.new(host, port, logger, telemetry)
+                    when :uds
+                      UDSConnection.new(socket_path, logger, telemetry)
+                    end
+
+      @logger = logger
 
       @sample_rate = sample_rate
 
       # we reduce max_buffer_bytes by a the rough estimate of the telemetry payload
-      @batch = Batch.new(@connection, (max_buffer_bytes - @telemetry.estimate_max_size))
+      @batch = Batch.new(connection, (max_buffer_bytes - telemetry.estimate_max_size))
     end
 
     # yield a new instance to a block and close it when done
@@ -259,20 +238,10 @@ module Datadog
     #   $statsd.time('account.activate') { @account.activate! }
     def time(stat, opts = EMPTY_OPTIONS)
       opts = { sample_rate: opts } if opts.is_a?(Numeric)
-      start = if PROCESS_TIME_SUPPORTED
-                Process.clock_gettime(Process::CLOCK_MONOTONIC) # uncovered
-              else
-                Time.now.to_f # uncovered
-              end
+      start = now
       yield
     ensure
-      finished =  if PROCESS_TIME_SUPPORTED
-                    Process.clock_gettime(Process::CLOCK_MONOTONIC) # uncovered
-                  else
-                    Time.now.to_f # uncovered
-                  end
-
-      timing(stat, ((finished - start) * 1000).round, opts)
+      timing(stat, ((now - start) * 1000).round, opts)
     end
 
     # Sends a value to be tracked as a set to the statsd server.
@@ -301,8 +270,9 @@ module Datadog
     # @example Report a critical service check status
     #   $statsd.service_check('my.service.check', Statsd::CRITICAL, :tags=>['urgent'])
     def service_check(name, status, opts = EMPTY_OPTIONS)
-      @telemetry.service_checks += 1
-      send_stat(format_service_check(name, status, opts))
+      telemetry.sent(service_checks: 1)
+
+      send_stat(serializer.to_service_check(name, status, opts))
     end
 
     # This end point allows you to post events to the stream. You can tag them, set priority and even aggregate them with other events.
@@ -324,8 +294,9 @@ module Datadog
     # @example Report an awful event:
     #   $statsd.event('Something terrible happened', 'The end is near if we do nothing', :alert_type=>'warning', :tags=>['end_of_times','urgent'])
     def event(title, text, opts = EMPTY_OPTIONS)
-      @telemetry.events += 1
-      send_stat(format_event(title, text, opts))
+      telemetry.sent(events: 1)
+
+      send_stat(serializer.to_event(title, text, opts))
     end
 
     # Send several metrics in the same UDP Packet
@@ -344,154 +315,44 @@ module Datadog
 
     # Close the underlying socket
     def close
-      @connection.close
+      connection.close
     end
 
     private
+    attr_reader :serializer
+    attr_reader :telemetry
 
-    NEW_LINE = "\n"
-    ESC_NEW_LINE = '\n'
-    COMMA = ','
-    PIPE = '|'
-    DOT = '.'
-    DOUBLE_COLON = '::'
-    UNDERSCORE = '_'
     PROCESS_TIME_SUPPORTED = (RUBY_VERSION >= '2.1.0')
     EMPTY_OPTIONS = {}.freeze
 
-    private_constant :NEW_LINE, :ESC_NEW_LINE, :COMMA, :PIPE, :DOT,
-      :DOUBLE_COLON, :UNDERSCORE, :EMPTY_OPTIONS
-
-    def format_service_check(name, status, opts = EMPTY_OPTIONS)
-      sc_string = "_sc|#{name}|#{status}".dup
-
-      SC_OPT_KEYS.each do |key, shorthand_key|
-        next unless opts[key]
-
-        if key == :tags
-          if tags_string = tags_as_string(opts)
-            sc_string << "|##{tags_string}"
-          end
-        elsif key == :message
-          message = remove_pipes(opts[:message])
-          escaped_message = escape_service_check_message(message)
-          sc_string << "|m:#{escaped_message}"
-        else
-          if key == :timestamp && opts[key].is_a?(Integer)
-            value = opts[key]
-          else
-            value = remove_pipes(opts[key])
-          end
-          sc_string << "|#{shorthand_key}#{value}"
-        end
-      end
-      sc_string
-    end
-
-    def format_event(title, text, opts = EMPTY_OPTIONS)
-      escaped_title = escape_event_content(title)
-      escaped_text = escape_event_content(text)
-      event_string_data = "_e{#{escaped_title.bytesize},#{escaped_text.bytesize}}:#{escaped_title}|#{escaped_text}".dup
-
-      # We construct the string to be sent by adding '|key:value' parts to it when needed
-      # All pipes ('|') in the metadata are removed. Title and Text can keep theirs
-      OPTS_KEYS.each do |key, shorthand_key|
-        if key != :tags && opts[key]
-          # :date_happened is the only key where the value is an Integer
-          # To not break backwards compatibility, we still accept a String
-          if key == :date_happened && opts[key].is_a?(Integer)
-              value = opts[key]
-          # All other keys only have String values
-          else
-              value = remove_pipes(opts[key])
-          end
-          event_string_data << "|#{shorthand_key}:#{value}"
-        end
-      end
-
-      # Tags are joined and added as last part to the string to be sent
-      if tags_string = tags_as_string(opts)
-        event_string_data << "|##{tags_string}"
+    if PROCESS_TIME_SUPPORTED
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
-
-      if event_string_data.bytesize > MAX_EVENT_SIZE
-        raise "Event #{title} payload is too big (more that 8KB), event discarded"
-      end
-      event_string_data
-    end
-
-    def tags_as_string(opts)
-      if tag_arr = opts[:tags]
-        tag_arr = tag_hash_to_array(tag_arr) if tag_arr.is_a?(Hash)
-        tag_arr = tag_arr.map do |tag|
-          escape_tag_content(tag)
-        end
-        tag_arr = tags + tag_arr # @tags are normalized when set, so not need to normalize them again
-      else
-        tag_arr = tags
+    else
+      def now
+        Time.now.to_f
       end
-      tag_arr.join(COMMA) unless tag_arr.empty?
-    end
-
-    def tag_hash_to_array(tag_hash)
-      tag_hash.to_a.map do |pair|
-        pair.compact.join(':')
-      end
-    end
-
-    def escape_event_content(message)
-      message.gsub(NEW_LINE, ESC_NEW_LINE)
-    end
-
-    def escape_tag_content(tag)
-      tag = remove_pipes(tag.to_s)
-      tag.delete!(COMMA)
-      tag
-    end
-
-    def remove_pipes(message)
-      message.delete(PIPE)
-    end
-
-    def escape_service_check_message(message)
-      escape_event_content(message).gsub('m:', 'm\:')
     end
 
     def send_stats(stat, delta, type, opts = EMPTY_OPTIONS)
-      @telemetry.metrics += 1
+      telemetry.sent(metrics: 1)
+
       sample_rate = opts[:sample_rate] || @sample_rate || 1
+
       if sample_rate == 1 || rand <= sample_rate
-        full_stat = ''.dup
-        full_stat << @prefix if @prefix
-
-        stat = stat.is_a?(String) ? stat.dup : stat.to_s
-        # Replace Ruby module scoping with '.' and reserved chars (: | @) with underscores.
-        stat.gsub!(DOUBLE_COLON, DOT)
-        stat.tr!(':|@', UNDERSCORE)
-        full_stat << stat
-
-        full_stat << ':'
-        full_stat << delta.to_s
-        full_stat << PIPE
-        full_stat << type
-
-        unless sample_rate == 1
-          full_stat << PIPE
-          full_stat << '@'
-          full_stat << sample_rate.to_s
-        end
-
-        if tags_string = tags_as_string(opts)
-          full_stat << PIPE
-          full_stat << '#'
-          full_stat << tags_string
-        end
+        full_stat = serializer.to_stat(stat, delta, type, tags: opts[:tags], sample_rate: sample_rate)
+
         send_stat(full_stat)
       end
     end
 
     def send_stat(message)
-      @batch.open? ? @batch.add(message) : @connection.write(message)
+      if @batch.open?
+        @batch.add(message)
+      else
+        @connection.write(message)
+      end
     end
   end
 end

data/lib/datadog/statsd/batch.rb

@@ -30,7 +30,7 @@ module Datadog
           if @buffer_bytes + 1 + message_bytes >= @max_buffer_bytes
             flush
           else
-            @buffer << NEW_LINE
+            @buffer << "\n"
             @buffer_bytes += 1
           end
         end

data/lib/datadog/statsd/connection.rb

@@ -9,24 +9,26 @@ module Datadog
 
       # Close the underlying socket
       def close
-        @socket && @socket.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?
-        if flush_telemetry
-          payload += @telemetry.flush()
-        end
+
+        flush_telemetry = telemetry.flush?
+
+        payload += telemetry.flush if flush_telemetry
 
         send_message(payload)
 
-        if flush_telemetry
-          @telemetry.reset
-        end
+        telemetry.reset if flush_telemetry
 
-        telemetry.bytes_sent += payload.length
-        telemetry.packets_sent += 1
+        telemetry.sent(packets: 1, bytes: payload.length)
       rescue StandardError => boom
         # Try once to reconnect if the socket has been closed
         retries ||= 1
@@ -36,21 +38,19 @@ module Datadog
            boom.is_a?(IOError) && boom.message =~ /closed stream/i)
           retries += 1
           begin
-            @socket = connect
+            close
             retry
           rescue StandardError => e
             boom = e
           end
         end
 
-        telemetry.bytes_dropped += payload.length
-        telemetry.packets_dropped += 1
+        telemetry.dropped(packets: 1, bytes: payload.length)
         logger.error { "Statsd: #{boom.class} #{boom}" } if logger
         nil
       end
 
       private
-
       attr_reader :telemetry
       attr_reader :logger
 

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,68 @@
+# 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
+
+            if raw_tags = options[:tags]
+              if tags = tag_serializer.format(raw_tags)
+                event << '|#'
+                event << tags
+              end
+            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,61 @@
+# 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
+
+            if raw_tags = options[:tags]
+              if tags = tag_serializer.format(raw_tags)
+                service_check << '|#'
+                service_check << tags
+              end
+            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

data/lib/datadog/statsd/telemetry.rb

@@ -4,21 +4,30 @@ 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
+      attr_reader :estimate_max_size
 
-      def initialize(disabled, tags, flush_interval)
+      def initialize(disabled, flush_interval, global_tags: [], transport_type: :udp)
         @disabled = disabled
-        @tags = tags
         @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)
+
         # 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
@@ -26,7 +35,7 @@ module Datadog
         # 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
+        @estimate_max_size = disabled ? 0 : flush.length + 9 * 7
       end
 
       def reset
@@ -37,28 +46,52 @@ 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 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 flush?
-        if @next_flush_time < Time.now.to_i
-          return true
-        end
-        return false
+        @next_flush_time < now_in_s
       end
 
       def flush
         return '' if @disabled
 
         # 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})
+        %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})
+      end
+
+      private
+      attr_reader :serialized_tags
+
+      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

@@ -17,7 +17,7 @@ module Datadog
       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)
+        @port = port || ENV.fetch('DD_DOGSTATSD_PORT', DEFAULT_PORT).to_i
         @logger = logger
       end
 

data/lib/datadog/statsd/uds_connection.rb

@@ -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 = '4.8.0'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dogstatsd-ruby
 version: !ruby/object:Gem::Version
-  version: 4.7.0
+  version: 4.8.0
 platform: ruby
 authors:
 - Rein Henrichs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-14 00:00:00.000000000 Z
+date: 2020-04-21 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby DogStastd client
 email: code@datadoghq.com
@@ -23,17 +23,24 @@ files:
 - lib/datadog/statsd.rb
 - lib/datadog/statsd/batch.rb
 - lib/datadog/statsd/connection.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
+  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v4.8.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/4.8.0
+  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v4.8.0
 post_install_message: 
 rdoc_options: []
 require_paths: