dogstatsd-ruby 4.4.0 → 4.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25baf4b0dc57e8ed9a79bd2115224f22de9097200ccf4931b54fbb1e40905363
-  data.tar.gz: a51c91dc366316b6edbadc64eb5e7383b6b100c9a2a859eb9bc31b9bef9ec7e2
+  metadata.gz: 9657b1d27b4367d96457d57faaed215c8ed07343d5d0803549b9078bd9713fbe
+  data.tar.gz: ad7c7fb2638790a3fe0300c23d81e87c33dc0fa9f7d496bc164e148e67e18992
 SHA512:
-  metadata.gz: 225ef009dcb475534ec746d9eaa6e8b156ad7b50291c2894ba9171806bc91231150510a65a47ec754dbf519f80fe7381c589d34f35e983519fb8e991347e1a12
-  data.tar.gz: e8609033506332625db4a6655adceacfb7fd1b85346020c1582dd032815ea56158d46442cecafd40fdd7bf098745e41ab1e70323b323ff63dd8bb43be3be8b88
+  metadata.gz: a6b5a0217129bdb2bb2e7da14711395775b2d8897f74ffd8bd9925dc6a5b8dd3503fe7ee8427e1840617197de251d5b46abe99284cf8df41928ad9b69399c814
+  data.tar.gz: c129849337907f82ddbeba16484371e18aa1f155d5fac46b1a62be31b178ceddcb3c47d04bf6ce59b1ea485770050918377dec4422d78f8b2c0d0e894794182f

data/README.md

@@ -1,86 +1,40 @@
+# dogstatsd-ruby
 
-dogstatsd-ruby
-==============
+A client for DogStatsD, an extension of the StatsD metric server for Datadog. Full API documentation is available in [DogStatsD-ruby rubydoc](https://www.rubydoc.info/github/DataDog/dogstatsd-ruby/master/Datadog/Statsd).
 
-A client for DogStatsD, an extension of the StatsD metric server for Datadog.
+[![Build Status](https://secure.travis-ci.org/DataDog/dogstatsd-ruby.svg)](http://travis-ci.org/DataDog/dogstatsd-ruby)
 
-[![Build Status](https://secure.travis-ci.org/DataDog/dogstatsd-ruby.png)](http://travis-ci.org/DataDog/dogstatsd-ruby)
+See [CHANGELOG.md](CHANGELOG.md) for changes. To suggest a feature, report a bug, or general discussion, [open an issue](http://github.com/DataDog/dogstatsd-ruby/issues/).
 
-Quick Start Guide
------------------
+## Installation
 
 First install the library:
 
-    gem install dogstatsd-ruby
+```
+gem install dogstatsd-ruby
+```
+
+## Configuration
 
-Then start instrumenting your code:
+To instantiate a DogStatsd client:
 
-``` ruby
-# Load the dogstats module.
+```ruby
+# Import the library
 require 'datadog/statsd'
 
-# Create a stats instance.
+# Create a DogStatsD client instance.
 statsd = Datadog::Statsd.new('localhost', 8125)
-
-# you could also create a statsd class if you need a drop in replacement
-# class Statsd < Datadog::Statsd
-# end
-
-# Increment a counter.
-statsd.increment('page.views')
-statsd.increment('messages.count', by: 2, tags: ['kind:incoming'])
-
-# Record a gauge 50% of the time.
-statsd.gauge('users.online', 123, sample_rate: 0.5)
-
-# Sample a histogram
-statsd.histogram('file.upload.size', 1234)
-
-# Time a block of code
-statsd.time('page.render') do
-  render_page('home.html')
-end
-
-# Send several metrics at the same time
-# All metrics will be buffered and sent in one packet when the block completes
-statsd.batch do |s|
-  s.increment('page.views')
-  s.gauge('users.online', 123)
-end
-
-# Tag a metric.
-statsd.histogram('query.time', 10, tags: ['version:1'])
-
-# Tag a metric by passing in a Hash
-statsd.histogram('query.time', 10, :tags => {version: 1})
-
-# Auto-close socket after end of block
-Datadog::Statsd.open('localhost', 8125) do |s|
-  s.increment('page.views')
-end
 ```
-
-You can also post events to your stream. You can tag them, set priority and even aggregate them with other events.
-
-Aggregation in the stream is made on hostname/event_type/source_type/aggregation_key.
-
-``` ruby
-# Post a simple message
-statsd.event('There might be a storm tomorrow', 'A friend warned me earlier.')
-
-# Cry for help
-statsd.event(
-  'SO MUCH SNOW',
-  "Started yesterday and it won't stop !!",
-  alert_type: 'error',
-  tags: ['urgent', 'endoftheworld']
-)
+Or if you want to connect over Unix Domain Socket:
+```ruby
+# Connection over Unix Domain Socket
+statsd = Datadog::Statsd.new(socket_path: '/path/to/socket/file')
 ```
 
+Find a list of all the available options for your DogStatsD Client in the [DogStatsD-ruby rubydoc](https://www.rubydoc.info/github/DataDog/dogstatsd-ruby/master/Datadog/Statsd) or in the [Datadog public DogStatsD documentation](https://docs.datadoghq.com/developers/dogstatsd/?tab=ruby#client-instantiation-parameters).
 
+### Origin detection over UDP
 
-Origin detection over UDP
--------------
 Origin detection is a method to detect which pod DogStatsD packets are coming from in order to add the pod's tags to the tag list.
 
 To enable origin detection over UDP, add the following lines to your application manifest
@@ -93,27 +47,31 @@ env:
 ```
 The DogStatsD client attaches an internal tag, `entity_id`. The value of this tag is the content of the `DD_ENTITY_ID` environment variable, which is the pod’s UID.
 
+## Usage
+
+In order to use DogStatsD metrics, events, and Service Checks the Agent must be [running and available](https://docs.datadoghq.com/developers/dogstatsd/?tab=ruby).
 
-Documentation
--------------
+### Metrics
 
-Full API documentation is available
-[here](http://www.rubydoc.info/github/DataDog/dogstatsd-ruby/master/frames).
+After the client is created, you can start sending custom metrics to Datadog. See the dedicated [Metric Submission: DogStatsD documentation](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby) to see how to submit all supported metric types to Datadog with working code examples:
 
+* [Submit a COUNT metric](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#count).
+* [Submit a GAUGE metric](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#gauge).
+* [Submit a SET metric](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#set)
+* [Submit a HISTOGRAM metric](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#histogram)
+* [Submit a DISTRIBUTION metric](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#distribution)
 
-Feedback
---------
+Some options are suppported when submitting metrics, like [applying a Sample Rate to your metrics](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#metric-submission-options) or [tagging your metrics with your custom tags](https://docs.datadoghq.com/developers/metrics/dogstatsd_metrics_submission/?tab=ruby#metric-tagging). Find all the available functions to report metrics in the [DogStatsD-ruby rubydoc](https://www.rubydoc.info/github/DataDog/dogstatsd-ruby/master/Datadog/Statsd).
 
-To suggest a feature, report a bug, or general discussion, head over
-[here](http://github.com/DataDog/dogstatsd-ruby/issues/).
+### Events
 
+After the client is created, you can start sending events to your Datadog Event Stream. See the dedicated [Event Submission: DogStatsD documentation](https://docs.datadoghq.com/developers/events/dogstatsd/?tab=ruby) to see how to submit an event to Datadog your Event Stream.
 
-[Change Log](CHANGELOG.md)
-----------------------------
+### Service Checks
 
+After the client is created, you can start sending Service Checks to Datadog. See the dedicated [Service Check Submission: DogStatsD documentation](https://docs.datadoghq.com/developers/service_checks/dogstatsd_service_checks_submission/?tab=ruby) to see how to submit a Service Check to Datadog.
 
-Credits
--------
+## Credits
 
 dogstatsd-ruby is forked from Rien Henrichs [original Statsd
 client](https://github.com/reinh/statsd).

data/lib/datadog/statsd.rb

@@ -1,6 +1,13 @@
 # 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)
 #
 # @example Set up a global Statsd client for a server on localhost:8125
@@ -19,186 +26,30 @@ require 'socket'
 #   statsd = Datadog::Statsd.new 'localhost', 8125, tags: 'tag1:true'
 module Datadog
   class Statsd
-
-    class 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
-
-      # DogStatsd unix socket path. Not used by default.
-      attr_reader :socket_path
-
-      # Close the underlying socket
-      def close
-        @socket && @socket.close
-      end
-
-      def write(message)
-        @logger.debug { "Statsd: #{message}" } if @logger
-        send_message(message)
-      rescue StandardError => boom
-        # Try once to reconnect if the socket has been closed
-        retries ||= 1
-        if retries <= 1 && boom.is_a?(Errno::ENOTCONN) or
-           retries <= 1 && boom.is_a?(IOError) && boom.message =~ /closed stream/i
-          retries += 1
-          begin
-            @socket = connect
-            retry
-          rescue StandardError => e
-            boom = e
-          end
-        end
-
-        @logger.error { "Statsd: #{boom.class} #{boom}" } if @logger
-        nil
-      end
-
-      private
-
-      def socket
-        @socket ||= connect
-      end
-    end
-
-    class UDPConnection < Connection
-      def initialize(host, port, logger)
-        @host = host || ENV.fetch('DD_AGENT_HOST', nil) || DEFAULT_HOST
-        @port = port || ENV.fetch('DD_DOGSTATSD_PORT', nil) || DEFAULT_PORT
-        @logger = logger
-      end
-
-      private
-
-      def connect
-        socket = UDPSocket.new
-        socket.connect(@host, @port)
-        socket
-      end
-
-      def send_message(message)
-        socket.send(message, 0)
-      end
-    end
-
-    class UDSConnection < Connection
-      class BadSocketError < StandardError; end
-
-      def initialize(socket_path, logger)
-        @socket_path = socket_path
-        @logger = logger
-      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
-        raise BadSocketError, "#{e.class}: #{e}"
-      end
-    end
-
-    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 << NEW_LINE
-            @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
-
-    # 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
-
-    MAX_EVENT_SIZE = 8 * 1024
-
-    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 = "4.4.0".freeze
+    OK       = 0
+    WARNING  = 1
+    CRITICAL = 2
+    UNKNOWN  = 3
+
+    DEFAULT_BUFFER_SIZE = 8 * 1_024
+    MAX_EVENT_SIZE = 8 * 1_024
+    # minimum flush interval for the telemetry in seconds
+    DEFAULT_TELEMETRY_FLUSH_INTERVAL = 10
+
+    COUNTER_TYPE = 'c'
+    GAUGE_TYPE = 'g'
+    HISTOGRAM_TYPE = 'h'
+    DISTRIBUTION_TYPE = 'd'
+    TIMING_TYPE = 'ms'
+    SET_TYPE = 's'
 
     # 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
@@ -225,40 +76,49 @@ module Datadog
       port = nil,
       namespace: nil,
       tags: nil,
-      max_buffer_bytes: 8192,
+      max_buffer_bytes: DEFAULT_BUFFER_SIZE,
       socket_path: nil,
       logger: nil,
-      sample_rate: nil
+      sample_rate: nil,
+      disable_telemetry: false,
+      telemetry_flush_interval: DEFAULT_TELEMETRY_FLUSH_INTERVAL
     )
-      if socket_path.nil?
-        @connection = UDPConnection.new(host, port, logger)
-      else
-        @connection = UDSConnection.new(socket_path, logger)
+      unless tags.nil? || tags.is_a?(Array) || tags.is_a?(Hash)
+        raise ArgumentError, 'tags must be a Array<String> or a Hash'
       end
-      @logger = logger
 
       @namespace = namespace
       @prefix = @namespace ? "#{@namespace}.".freeze : nil
 
-      @sample_rate = sample_rate
+      @serializer = Serialization::Serializer.new(prefix: @prefix, global_tags: tags)
 
-      unless tags.nil? or tags.is_a? Array or tags.is_a? Hash
-        raise ArgumentError, 'tags must be a Array<String> or a Hash'
-      end
+      transport_type = socket_path.nil? ? :udp : :uds
+
+      @telemetry = Telemetry.new(disable_telemetry, telemetry_flush_interval,
+        global_tags: tags,
+        transport_type: transport_type
+      )
+
+      @connection = case transport_type
+                    when :udp
+                      UDPConnection.new(host, port, logger, telemetry)
+                    when :uds
+                      UDSConnection.new(socket_path, logger, telemetry)
+                    end
 
-      tags = tag_hash_to_array(tags) if tags.is_a? Hash
-      @tags = (tags || []).compact.map! {|tag| escape_tag_content(tag)}
+      @logger = logger
 
-      # append the entity id to tags if DD_ENTITY_ID env var is not nil
-      @tags << 'dd.internal.entity_id:' + escape_tag_content(ENV.fetch('DD_ENTITY_ID', nil)) unless ENV.fetch('DD_ENTITY_ID', nil).nil?
+      @sample_rate = sample_rate
 
-      @batch = Batch.new @connection, max_buffer_bytes
+      # 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))
     end
 
     # 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
     def self.open(*args)
       instance = new(*args)
+
       yield instance
     ensure
       instance.close
@@ -272,10 +132,10 @@ module Datadog
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by increment value, default 1
     # @see #count
-    def increment(stat, opts=EMPTY_OPTIONS)
-      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.
@@ -286,10 +146,10 @@ module Datadog
     # @option opts [Array<String>] :tags An array of tags
     # @option opts [Numeric] :by decrement value, default 1
     # @see #count
-    def decrement(stat, opts=EMPTY_OPTIONS)
-      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.
@@ -299,9 +159,9 @@ module Datadog
     # @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
-    def count(stat, count, opts=EMPTY_OPTIONS)
-      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.
@@ -317,9 +177,9 @@ module Datadog
     # @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=EMPTY_OPTIONS)
-      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.
@@ -331,14 +191,11 @@ module Datadog
     # @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=EMPTY_OPTIONS)
-      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.
@@ -347,8 +204,8 @@ module Datadog
     # @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=EMPTY_OPTIONS)
-      send_stats stat, value, DISTRIBUTION_TYPE, opts
+    def distribution(stat, value, opts = EMPTY_OPTIONS)
+      send_stats(stat, value, DISTRIBUTION_TYPE, opts)
     end
 
     # Sends a timing (in ms) for the given stat to the statsd server. The
@@ -361,9 +218,9 @@ module Datadog
     # @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
-    def timing(stat, ms, opts=EMPTY_OPTIONS)
-      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}.
@@ -379,13 +236,12 @@ module Datadog
     # @see #timing
     # @example Report the time (in ms) taken to activate an account
     #   $statsd.time('account.activate') { @account.activate! }
-    def time(stat, opts=EMPTY_OPTIONS)
-      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.
@@ -397,9 +253,9 @@ module Datadog
     # @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=EMPTY_OPTIONS)
-      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.
@@ -413,8 +269,10 @@ module Datadog
       # @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=EMPTY_OPTIONS)
-      send_stat format_service_check(name, status, opts)
+    def service_check(name, status, opts = EMPTY_OPTIONS)
+      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.
@@ -435,8 +293,10 @@ module Datadog
     # @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=EMPTY_OPTIONS)
-      send_stat format_event(title, text, opts)
+    def event(title, text, opts = EMPTY_OPTIONS)
+      telemetry.sent(events: 1)
+
+      send_stat(serializer.to_event(title, text, opts))
     end
 
     # Send several metrics in the same UDP Packet
@@ -448,146 +308,40 @@ module Datadog
     #      s.increment('page.views')
     #    end
     def batch
-      @batch.open { yield self }
+      @batch.open do
+        yield self
+      end
     end
 
     # Close the underlying socket
     def close
-      @connection.close
+      connection.close
     end
 
     private
+    attr_reader :serializer
+    attr_reader :telemetry
 
-    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")
+    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
-
-      raise "Event #{title} payload is too big (more that 8KB), event discarded" if event_string_data.bytesize > MAX_EVENT_SIZE
-      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 { |tag| escape_tag_content(tag) }
-        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 {|pair| pair.compact.join(":")}
-    end
-
-    def escape_event_content(msg)
-      msg.gsub NEW_LINE, ESC_NEW_LINE
-    end
-
-    def escape_tag_content(tag)
-      tag = remove_pipes(tag.to_s)
-      tag.delete! COMMA
-      tag
-    end
+    def send_stats(stat, delta, type, opts = EMPTY_OPTIONS)
+      telemetry.sent(metrics: 1)
 
-    def remove_pipes(msg)
-      msg.delete PIPE
-    end
-
-    def escape_service_check_message(msg)
-      escape_event_content(msg).gsub('m:'.freeze, 'm\:'.freeze)
-    end
-
-    def send_stats(stat, delta, type, opts=EMPTY_OPTIONS)
       sample_rate = opts[:sample_rate] || @sample_rate || 1
-      if sample_rate == 1 or 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!(':|@'.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
+
+      if sample_rate == 1 || rand <= sample_rate
+        full_stat = serializer.to_stat(stat, delta, type, tags: opts[:tags], sample_rate: sample_rate)
 
         send_stat(full_stat)
       end
@@ -595,7 +349,7 @@ module Datadog
 
     def send_stat(message)
       if @batch.open?
-        @batch.add message
+        @batch.add(message)
       else
         @connection.write(message)
       end