dogstatsd-ruby 3.3.0 → 5.6.1

data/lib/datadog/statsd.rb

@@ -1,5 +1,18 @@
+# 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/connection_cfg'
+require_relative 'statsd/message_buffer'
+require_relative 'statsd/serialization'
+require_relative 'statsd/sender'
+require_relative 'statsd/single_thread_sender'
+require_relative 'statsd/forwarder'
+require_relative 'statsd/timer'
+
 # = Datadog::Statsd: A DogStatsd client (https://www.datadoghq.com)
 #
 # @example Set up a global Statsd client for a server on localhost:8125
@@ -15,109 +28,127 @@ require 'socket'
 #   statsd = Datadog::Statsd.new 'localhost', 8125, :namespace => 'account'
 #   statsd.increment 'activate'
 # @example Create a statsd client with global tags
-#   statsd = Datadog::Statsd.new 'localhost', 8125, :tags => 'tag1:true'
+#   statsd = Datadog::Statsd.new 'localhost', 8125, tags: 'tag1:true'
 module Datadog
   class Statsd
+    class Error < StandardError
+    end
 
-    DEFAULT_HOST = '127.0.0.1'
-    DEFAULT_PORT = 8125
-
-    # 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,
-    }
-
-    # Service check options
-    SC_OPT_KEYS = {
-      :timestamp  => 'd:'.freeze,
-      :hostname   => 'h:'.freeze,
-      :tags       => '#'.freeze,
-      :message    => 'm:'.freeze,
-    }
-
-    OK        = 0
-    WARNING   = 1
-    CRITICAL  = 2
-    UNKNOWN   = 3
-
-    COUNTER_TYPE = 'c'.freeze
-    GAUGE_TYPE = 'g'.freeze
-    HISTOGRAM_TYPE = 'h'.freeze
-    DISTRIBUTION_TYPE = 'd'.freeze
-    TIMING_TYPE = 'ms'.freeze
-    SET_TYPE = 's'.freeze
-    VERSION = "3.3.0".freeze
+    OK       = 0
+    WARNING  = 1
+    CRITICAL = 2
+    UNKNOWN  = 3
 
-    # A namespace to prepend to all statsd calls. Defaults to no namespace.
-    attr_reader :namespace
+    UDP_DEFAULT_BUFFER_SIZE = 1_432
+    UDS_DEFAULT_BUFFER_SIZE = 8_192
+    DEFAULT_BUFFER_POOL_SIZE = Float::INFINITY
 
-    # StatsD host. Defaults to 127.0.0.1.
-    attr_reader :host
+    UDP_DEFAULT_SENDER_QUEUE_SIZE = 2048
+    UDS_DEFAULT_SENDER_QUEUE_SIZE = 512
 
-    # StatsD port. Defaults to 8125.
-    attr_reader :port
+    MAX_EVENT_SIZE = 8 * 1_024
 
-    # DogStatsd unix socket path. Not used by default.
-    attr_reader :socket_path
+    # minimum flush interval for the telemetry in seconds
+    DEFAULT_TELEMETRY_FLUSH_INTERVAL = 10
 
-    # Global tags to be added to every statsd call. Defaults to no tags.
-    attr_reader :tags
+    COUNTER_TYPE = 'c'
+    GAUGE_TYPE = 'g'
+    HISTOGRAM_TYPE = 'h'
+    DISTRIBUTION_TYPE = 'd'
+    TIMING_TYPE = 'ms'
+    SET_TYPE = 's'
 
-    # Buffer containing the statsd message before they are sent in batch
-    attr_reader :buffer
-
-    # Maximum number of metrics in the buffer before it is flushed
-    attr_accessor :max_buffer_size
+    # A namespace to prepend to all statsd calls. Defaults to no namespace.
+    attr_reader :namespace
 
-    class << self
-      # Set to a standard logger instance to enable debug logging.
-      attr_accessor :logger
+    # Global tags to be added to every statsd call. Defaults to no tags.
+    def tags
+      serializer.global_tags
     end
 
-    # Return the current version of the library.
-    # deprecated, but cannot be removed since uses might use it to check the version against older releases
-    def self.VERSION
-      VERSION
-    end
+    # Default sample rate
+    attr_reader :sample_rate
 
     # @param [String] host your statsd host
     # @param [Integer] port your statsd port
-    # @option opts [String] :namespace set a namespace to be prepended to every metric name
-    # @option opts [Array<String>] :tags tags to be added to every metric
-    def initialize(host = DEFAULT_HOST, port = DEFAULT_PORT, opts = {}, max_buffer_size=50)
-      self.host, self.port = host, port
-      @socket_path = opts[:socket_path]
-      @prefix = nil
-      @socket = connect_to_socket if @socket_path.nil?
-      self.namespace = opts[:namespace]
-      self.tags = opts[:tags]
-      @buffer = Array.new
-      self.max_buffer_size = max_buffer_size
-      @batch_nesting_depth = 0
-    end
+    # @option [String] namespace set a namespace to be prepended to every metric name
+    # @option [Array<String>|Hash] tags tags to be added to every metric
+    # @option [Logger] logger for debugging
+    # @option [Integer] buffer_max_payload_size max bytes to buffer
+    # @option [Integer] buffer_max_pool_size max messages to buffer
+    # @option [Integer] sender_queue_size size of the sender queue in number of buffers
+    # @option [Numeric] buffer_flush_interval interval in second to flush buffer
+    # @option [String] socket_path unix socket path
+    # @option [Float] default sample rate if not overridden
+    # @option [Boolean] single_thread flushes the metrics on the main thread instead of in a companion thread
+    # @option [Boolean] delay_serialization delays stat serialization
+    def initialize(
+      host = nil,
+      port = nil,
+      socket_path: nil,
+
+      namespace: nil,
+      tags: nil,
+      sample_rate: nil,
+
+      buffer_max_payload_size: nil,
+      buffer_max_pool_size: nil,
+      buffer_overflowing_stategy: :drop,
+      buffer_flush_interval: nil,
+
+      sender_queue_size: nil,
+
+      logger: nil,
+
+      single_thread: false,
+      delay_serialization: false,
+
+      telemetry_enable: true,
+      telemetry_flush_interval: DEFAULT_TELEMETRY_FLUSH_INTERVAL
+    )
+      unless tags.nil? || tags.is_a?(Array) || tags.is_a?(Hash)
+        raise ArgumentError, 'tags must be an array of string tags or a Hash'
+      end
 
-    def namespace=(namespace) #:nodoc:
       @namespace = namespace
-      @prefix = namespace.nil? ? nil : "#{namespace}.".freeze
-    end
+      @prefix = @namespace ? "#{@namespace}.".freeze : nil
+      @serializer = Serialization::Serializer.new(prefix: @prefix, global_tags: tags)
+      @sample_rate = sample_rate
+      @delay_serialization = delay_serialization
 
-    def host=(host) #:nodoc:
-      @host = host || DEFAULT_HOST
-    end
+      @forwarder = Forwarder.new(
+        connection_cfg: ConnectionCfg.new(
+          host: host,
+          port: port,
+          socket_path: socket_path,
+        ),
+
+        global_tags: tags,
+        logger: logger,
+
+        single_thread: single_thread,
 
-    def port=(port) #:nodoc:
-      @port = port || DEFAULT_PORT
+        buffer_max_payload_size: buffer_max_payload_size,
+        buffer_max_pool_size: buffer_max_pool_size,
+        buffer_overflowing_stategy: buffer_overflowing_stategy,
+        buffer_flush_interval: buffer_flush_interval,
+
+        sender_queue_size: sender_queue_size,
+
+        telemetry_flush_interval: telemetry_enable ? telemetry_flush_interval : nil,
+        serializer: serializer
+      )
     end
 
-    def tags=(tags) #:nodoc:
-      raise ArgumentError, 'tags must be a Array<String>' unless tags.nil? or tags.is_a? Array
-      @tags = (tags || []).compact.map! {|tag| escape_tag_content(tag)}
+    # yield a new instance to a block and close it when done
+    # for short-term use-cases that don't want to close the socket manually
+    # TODO: replace with ... once we are on ruby 2.7
+    def self.open(*args, **kwargs)
+      instance = new(*args, **kwargs)
+
+      yield instance
+    ensure
+      instance.close if instance
     end
 
     # Sends an increment (count = 1) for the given stat to the statsd server.
@@ -125,13 +156,14 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by increment value, default 1
     # @see #count
-    def increment(stat, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
+    def increment(stat, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
       incr_value = opts.fetch(:by, 1)
-      count stat, incr_value, opts
+      count(stat, incr_value, opts)
     end
 
     # Sends a decrement (count = -1) for the given stat to the statsd server.
@@ -139,13 +171,14 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by decrement value, default 1
     # @see #count
-    def decrement(stat, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
+    def decrement(stat, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
       decr_value = - opts.fetch(:by, 1)
-      count stat, decr_value, opts
+      count(stat, decr_value, opts)
     end
 
     # Sends an arbitrary count for the given stat to the statsd server.
@@ -154,13 +187,14 @@ module Datadog
     # @param [Integer] count count
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
-    def count(stat, count, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
-      send_stats stat, count, COUNTER_TYPE, opts
+    def count(stat, count, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      send_stats(stat, count, COUNTER_TYPE, opts)
     end
 
-    # Sends an arbitary gauge value for the given stat to the statsd server.
+    # Sends an arbitrary gauge value for the given stat to the statsd server.
     #
     # This is useful for recording things like available disk space,
     # memory usage, and the like, which have different semantics than
@@ -170,12 +204,13 @@ module Datadog
     # @param [Numeric] value gauge value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.gauge('user.count', User.count)
-    def gauge(stat, value, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
-      send_stats stat, value, GAUGE_TYPE, opts
+    def gauge(stat, value, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      send_stats(stat, value, GAUGE_TYPE, opts)
     end
 
     # Sends a value to be tracked as a histogram to the statsd server.
@@ -184,27 +219,46 @@ module Datadog
     # @param [Numeric] value histogram value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.histogram('user.count', User.count)
-    def histogram(stat, value, opts={})
-      send_stats stat, value, HISTOGRAM_TYPE, opts
+    def histogram(stat, value, opts = EMPTY_OPTIONS)
+      send_stats(stat, value, HISTOGRAM_TYPE, opts)
     end
 
     # Sends a value to be tracked as a distribution to the statsd server.
-    # Note: Distributions are a beta feature of Datadog and not generally
-    # available. Distributions must be specifically enabled for your
-    # organization.
     #
     # @param [String] stat stat name.
     # @param [Numeric] value distribution value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Report the current user count:
     #   $statsd.distribution('user.count', User.count)
-    def distribution(stat, value, opts={})
-      send_stats stat, value, DISTRIBUTION_TYPE, opts
+    def distribution(stat, value, opts = EMPTY_OPTIONS)
+      send_stats(stat, value, DISTRIBUTION_TYPE, opts)
+    end
+
+    # Reports execution time of the provided block as a distribution.
+    #
+    # If the block fails, the stat is still reported, then the error
+    # is reraised
+    #
+    # @param [String] stat stat name.
+    # @param [Numeric] value distribution value.
+    # @param [Hash] opts the options to create the metric with
+    # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Array<String>] :tags An array of tags
+    # @example Report the time (in ms) taken to activate an account
+    #   $statsd.distribution_time('account.activate') { @account.activate! }
+    def distribution_time(stat, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      start = now
+      yield
+    ensure
+      distribution(stat, ((now - start) * 1000).round, opts)
     end
 
     # Sends a timing (in ms) for the given stat to the statsd server. The
@@ -216,10 +270,11 @@ module Datadog
     # @param [Integer] ms timing in milliseconds
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
-    def timing(stat, ms, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
-      send_stats stat, ms, TIMING_TYPE, opts
+    def timing(stat, ms, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      send_stats(stat, ms, TIMING_TYPE, opts)
     end
 
     # Reports execution time of the provided block using {#timing}.
@@ -230,31 +285,33 @@ module Datadog
     # @param [String] stat stat name
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @yield The operation to be timed
     # @see #timing
     # @example Report the time (in ms) taken to activate an account
     #   $statsd.time('account.activate') { @account.activate! }
-    def time(stat, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
-      start = (PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : Time.now.to_f)
-      return yield
+    def time(stat, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      start = now
+      yield
     ensure
-      finished = (PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : Time.now.to_f)
-      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.
     #
     # @param [String] stat stat name.
     # @param [Numeric] value set value.
     # @param [Hash] opts the options to create the metric with
     # @option opts [Numeric] :sample_rate sample rate, 1 for always
+    # @option opts [Boolean] :pre_sampled If true, the client assumes the caller has already sampled metrics at :sample_rate, and doesn't perform sampling.
     # @option opts [Array<String>] :tags An array of tags
     # @example Record a unique visitory by id:
     #   $statsd.set('visitors.uniques', User.id)
-    def set(stat, value, opts={})
-      opts = {:sample_rate => opts} if opts.is_a? Numeric
-      send_stats stat, value, SET_TYPE, opts
+    def set(stat, value, opts = EMPTY_OPTIONS)
+      opts = { sample_rate: opts } if opts.is_a?(Numeric)
+      send_stats(stat, value, SET_TYPE, opts)
     end
 
     # This method allows you to send custom service check statuses.
@@ -262,37 +319,16 @@ module Datadog
     # @param [String] name Service check name
     # @param [String] status Service check status.
     # @param [Hash] opts the additional data about the service check
-      # @option opts [Integer, nil] :timestamp (nil) Assign a timestamp to the event. Default is now when none
-      # @option opts [String, nil] :hostname (nil) Assign a hostname to the event.
+      # @option opts [Integer, String, nil] :timestamp (nil) Assign a timestamp to the service check. Default is now when none
+      # @option opts [String, nil] :hostname (nil) Assign a hostname to the service check.
       # @option opts [Array<String>, nil] :tags (nil) An array of tags
       # @option opts [String, nil] :message (nil) A message to associate with this service check status
     # @example Report a critical service check status
     #   $statsd.service_check('my.service.check', Statsd::CRITICAL, :tags=>['urgent'])
-    def service_check(name, status, opts={})
-      service_check_string = format_service_check(name, status, opts)
-      send_to_socket service_check_string
-    end
-
-    def format_service_check(name, status, opts={})
-      sc_string = "_sc|#{name}|#{status}"
+    def service_check(name, status, opts = EMPTY_OPTIONS)
+      telemetry.sent(service_checks: 1) if telemetry
 
-      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
-          value = remove_pipes(opts[key])
-          sc_string << "|#{shorthand_key}#{value}"
-        end
-      end
-      return sc_string
+      forwarder.send_message(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.
@@ -302,197 +338,106 @@ module Datadog
     # it will be grouped with other events that don't have an event type.
     #
     # @param [String] title Event title
-    # @param [String] text Event text. Supports \n
+    # @param [String] text Event text. Supports newlines (+\n+)
     # @param [Hash] opts the additional data about the event
-    # @option opts [Integer, nil] :date_happened (nil) Assign a timestamp to the event. Default is now when none
+    # @option opts [Integer, String, nil] :date_happened (nil) Assign a timestamp to the event. Default is now when none
     # @option opts [String, nil] :hostname (nil) Assign a hostname to the event.
     # @option opts [String, nil] :aggregation_key (nil) Assign an aggregation key to the event, to group it with some others
     # @option opts [String, nil] :priority ('normal') Can be "normal" or "low"
     # @option opts [String, nil] :source_type_name (nil) Assign a source type to the event
     # @option opts [String, nil] :alert_type ('info') Can be "error", "warning", "info" or "success".
+    # @option opts [Boolean, false] :truncate_if_too_long (false) Truncate the event if it is too long
     # @option opts [Array<String>] :tags tags to be added to every metric
     # @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={})
-      event_string = format_event(title, text, opts)
-      raise "Event #{title} payload is too big (more that 8KB), event discarded" if event_string.length > 8 * 1024
+    def event(title, text, opts = EMPTY_OPTIONS)
+      telemetry.sent(events: 1) if telemetry
 
-      send_to_socket event_string
+      forwarder.send_message(serializer.to_event(title, text, opts))
     end
 
-    # Send several metrics in the same UDP Packet
-    # They will be buffered and flushed when the block finishes
+    # Send several metrics in the same packet.
+    # They will be buffered and flushed when the block finishes.
+    #
+    # This method exists for compatibility with v4.x versions, it is not needed
+    # anymore since the batching is now automatically done internally.
+    # It also means that an automatic flush could occur if the buffer is filled
+    # during the execution of the batch block.
+    #
+    # This method is DEPRECATED and will be removed in future v6.x API.
     #
     # @example Send several metrics in one packet:
     #   $statsd.batch do |s|
     #      s.gauge('users.online',156)
     #      s.increment('page.views')
     #    end
-    def batch()
-      @batch_nesting_depth += 1
+    def batch
       yield self
-    ensure
-      @batch_nesting_depth -= 1
-      flush_buffer if @batch_nesting_depth == 0
-    end
-
-    def format_event(title, text, opts={})
-      escaped_title = escape_event_content(title)
-      escaped_text = escape_event_content(text)
-      event_string_data = "_e{#{escaped_title.length},#{escaped_text.length}}:#{escaped_title}|#{escaped_text}"
-
-      # 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]
-          value = remove_pipes(opts[key])
-          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}"
-      end
-
-      raise "Event #{title} payload is too big (more that 8KB), event discarded" if event_string_data.length > 8192 # 8 * 1024 = 8192
-      return event_string_data
+      flush(sync: true)
     end
 
     # Close the underlying socket
-    def close()
-      @socket.close
+    #
+    # @param [Boolean, true] flush Should we flush the metrics before closing
+    def close(flush: true)
+      flush(sync: true) if flush
+      forwarder.close
     end
 
-    private
-
-    NEW_LINE = "\n".freeze
-    ESC_NEW_LINE = "\\n".freeze
-    COMMA = ",".freeze
-    PIPE = "|".freeze
-    DOT = ".".freeze
-    DOUBLE_COLON = "::".freeze
-    UNDERSCORE = "_".freeze
-    PROCESS_TIME_SUPPORTED = (RUBY_VERSION >= "2.1.0")
-
-    private_constant :NEW_LINE, :ESC_NEW_LINE, :COMMA, :PIPE, :DOT,
-      :DOUBLE_COLON, :UNDERSCORE
-
-    def tags_as_string(opts)
-      tag_arr = opts[:tags] || []
-      tag_arr = tag_arr.map { |tag| escape_tag_content(tag) }
-      tag_arr = tags + tag_arr # @tags are normalized when set, so not need to normalize them again
-      tag_arr.join(COMMA) unless tag_arr.empty?
+    def sync_with_outbound_io
+      forwarder.sync_with_outbound_io
     end
 
-    def escape_event_content(msg)
-      msg.gsub NEW_LINE, ESC_NEW_LINE
+    # Flush the buffer into the connection
+    def flush(flush_telemetry: false, sync: false)
+      forwarder.flush(flush_telemetry: flush_telemetry, sync: sync)
     end
 
-    def escape_tag_content(tag)
-      tag = remove_pipes(tag.to_s)
-      tag.delete! COMMA
-      tag
+    def telemetry
+      forwarder.telemetry
     end
 
-    def remove_pipes(msg)
-      msg.delete PIPE
+    def host
+      forwarder.host
     end
 
-    def escape_service_check_message(msg)
-      escape_event_content(msg).gsub('m:'.freeze, 'm\:'.freeze)
+    def port
+      forwarder.port
     end
 
-    def send_stats(stat, delta, type, opts={})
-      sample_rate = opts[:sample_rate] || 1
-      if sample_rate == 1 or rand < sample_rate
-        full_stat = ''
-        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!(':|@'.freeze, UNDERSCORE)
-        full_stat << stat
-
-        full_stat << ':'.freeze
-        full_stat << delta.to_s
-        full_stat << PIPE
-        full_stat << type
-
-        unless sample_rate == 1
-          full_stat << PIPE
-          full_stat << '@'.freeze
-          full_stat << sample_rate.to_s
-        end
-
-        if tags_string = tags_as_string(opts)
-          full_stat << PIPE
-          full_stat << '#'.freeze
-          full_stat << tags_string
-        end
-
-        send_stat(full_stat)
-      end
+    def socket_path
+      forwarder.socket_path
     end
 
-    def send_stat(message)
-      if @batch_nesting_depth > 0
-        @buffer << message
-        flush_buffer if @buffer.length >= @max_buffer_size
-      else
-        send_to_socket(message)
-      end
+    def transport_type
+      forwarder.transport_type
     end
 
-    def flush_buffer
-      return @buffer if @buffer.empty?
-      send_to_socket(@buffer.join(NEW_LINE))
-      @buffer = Array.new
-    end
+    private
+    attr_reader :serializer
+    attr_reader :forwarder
 
-    def connect_to_socket
-      if !@socket_path.nil?
-        socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM)
-        socket.connect(Socket.pack_sockaddr_un(@socket_path))
-      else
-        socket = UDPSocket.new
-        socket.connect(@host, @port)
-      end
-      socket
-    end
+    EMPTY_OPTIONS = {}.freeze
 
-    def sock
-      @socket ||= connect_to_socket
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def send_to_socket(message)
-      self.class.logger.debug { "Statsd: #{message}" } if self.class.logger
-      if @socket_path.nil?
-        sock.send(message, 0)
-      else
-        sock.sendmsg_nonblock(message)
-      end
-    rescue => boom
-      if @socket_path && (boom.is_a?(Errno::ECONNREFUSED) ||
-                          boom.is_a?(Errno::ECONNRESET) ||
-                          boom.is_a?(Errno::ENOENT))
-        return @socket = nil
-      end
-      # Try once to reconnect if the socket has been closed
-      retries ||= 1
-      if retries <= 1 && boom.is_a?(IOError) && boom.message =~ /closed stream/i
-        retries += 1
-        begin
-          @socket = connect_to_socket
-          retry
-        rescue => e
-          boom = e
-        end
-      end
+    def send_stats(stat, delta, type, opts = EMPTY_OPTIONS)
+      telemetry.sent(metrics: 1) if telemetry
 
-      self.class.logger.error { "Statsd: #{boom.class} #{boom}" } if self.class.logger
-      nil
+      sample_rate = opts[:sample_rate] || @sample_rate || 1
+
+      if sample_rate == 1 || opts[:pre_sampled] || rand <= sample_rate
+        full_stat =
+          if @delay_serialization
+            [[stat, delta, type], {tags: opts[:tags], sample_rate: sample_rate}]
+          else
+            serializer.to_stat(stat, delta, type, tags: opts[:tags], sample_rate: sample_rate)
+          end
+
+        forwarder.send_message(full_stat)
+      end
     end
   end
 end