dogstatsd-ruby 4.1.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdab85fe0b81950fd3e672109edd29b4e9d9a4362e567ed9e9a14e2f95f46ec8
-  data.tar.gz: 4b6040d520cc243cb045a970f7011d3cd878e2a6e8a9f7be2a496d1994c07214
+  metadata.gz: 7d521571f811d6206670773db4ac3808c02513d8761445ecf917f831578e2614
+  data.tar.gz: 97d68494f8520a777569dc8f7b3c04070152aa0924edabc67ffa0ae1f16cb615
 SHA512:
-  metadata.gz: 1d73c1e3e5c9d7d27fc965f79137dee176ea7bc6d7a520e8a4658329bfbd780b9aadd71d636e4f9652d675f888cce1c24902ebb79c3af7aebb39b4b730bb0c7b
-  data.tar.gz: 1f5ae46a3955844f74748e3fdacac487685efbfa2f270c178e9a2e99791cf00bce9e2200809276ca263f9d2dda1b606a593a4e33a44bb3c2cbfef2f33341f330
+  metadata.gz: f43fb9314373873b5d436824a3cae0a5dc0ef4fcc2a458b8a98b98dbd8b12cb28d3b32293436451829a53da8cb70f17c6104aa64403cfb6000822e59a74ca29a
+  data.tar.gz: a796456e38da22047d952b7a1bebaf1f923a0847c29a9e7548020c8b658144e729133e7e90a16453d0f48a815353734523870e2e391371d8699f1d6574bd8379

data/README.md

@@ -1,95 +1,72 @@
+# 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')
-
-# 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"])
-
-# 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.
+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=go#client-instantiation-parameters).
 
-Aggregation in the stream is made on hostname/event_type/source_type/aggregation_key.
+### Origin detection over UDP
 
-``` ruby
-# Post a simple message
-statsd.event("There might be a storm tomorrow", "A friend warned me earlier.")
+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.
 
-# Cry for help
-statsd.event("SO MUCH SNOW", "Started yesterday and it won't stop !!", :alert_type => "error", :tags => ["urgent", "endoftheworld"])
+To enable origin detection over UDP, add the following lines to your application manifest
+```yaml
+env:
+  - name: DD_ENTITY_ID
+    valueFrom:
+      fieldRef:
+        fieldPath: metadata.uid
 ```
+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

@@ -20,6 +20,56 @@ require 'socket'
 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
+
+      def initialize(disabled, tags)
+        @disabled = disabled
+        @tags = tags
+        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
+      end
+
+      def reset
+        @metrics = 0
+        @events = 0
+        @service_checks = 0
+        @bytes_sent = 0
+        @bytes_dropped = 0
+        @packets_sent = 0
+        @packets_dropped = 0
+      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})
+      end
+    end
+
     class Connection
       DEFAULT_HOST = '127.0.0.1'
       DEFAULT_PORT = 8125
@@ -33,36 +83,30 @@ module Datadog
       # DogStatsd unix socket path. Not used by default.
       attr_reader :socket_path
 
-      def initialize(host, port, socket_path, logger)
-        @host = host || DEFAULT_HOST
-        @port = port || DEFAULT_PORT
-        @socket_path = socket_path
-        @logger = logger
+      def initialize(telemetry)
+        @telemetry = telemetry
+      end
+
+      # Close the underlying socket
+      def close
+        @socket && @socket.close
       end
 
       def write(message)
         @logger.debug { "Statsd: #{message}" } if @logger
-        if @socket_path.nil?
-          socket.send(message, 0)
-        else
-          socket.sendmsg_nonblock(message)
-        end
-      rescue StandardError => boom
-        # Give up on this socket if it looks like it is bad
-        bad_socket = !@socket_path.nil? && (
-          boom.is_a?(Errno::ECONNREFUSED) ||
-          boom.is_a?(Errno::ECONNRESET) ||
-          boom.is_a?(Errno::ENOENT)
-        )
-        if bad_socket
-          @socket = nil
-          return
-        end
+        payload = message + @telemetry.flush()
+        send_message(payload)
 
+        @telemetry.reset
+        @telemetry.bytes_sent += payload.length
+        @telemetry.packets_sent += 1
+      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
+        if retries <= 1 &&
+          (boom.is_a?(Errno::ENOTCONN) or
+           boom.is_a?(Errno::ECONNREFUSED) or
+           boom.is_a?(IOError) && boom.message =~ /closed stream/i)
           retries += 1
           begin
             @socket = connect
@@ -72,31 +116,63 @@ module Datadog
           end
         end
 
+        @telemetry.bytes_dropped += payload.length
+        @telemetry.packets_dropped += 1
         @logger.error { "Statsd: #{boom.class} #{boom}" } if @logger
         nil
       end
 
-      # Close the underlying socket
-      def close
-        @socket && @socket.close
-      end
-
       private
 
       def socket
         @socket ||= connect
       end
+    end
+
+    class UDPConnection < Connection
+      def initialize(host, port, logger, telemetry)
+        super(telemetry)
+        @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
-        if @socket_path.nil?
-          socket = UDPSocket.new
-          socket.connect(@host, @port)
-        else
-          socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM)
-          socket.connect(Socket.pack_sockaddr_un(@socket_path))
-        end
+        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, telemetry)
+        super(telemetry)
+        @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
@@ -173,7 +249,8 @@ module Datadog
     CRITICAL  = 2
     UNKNOWN   = 3
 
-    MAX_EVENT_SIZE = 8 * 1024
+    DEFAULT_BUFFER_SIZE = 8 * 1_024
+    MAX_EVENT_SIZE = 8 * 1_024
 
     COUNTER_TYPE = 'c'.freeze
     GAUGE_TYPE = 'g'.freeze
@@ -181,7 +258,7 @@ module Datadog
     DISTRIBUTION_TYPE = 'd'.freeze
     TIMING_TYPE = 'ms'.freeze
     SET_TYPE = 's'.freeze
-    VERSION = "4.1.0".freeze
+    VERSION = "4.6.0".freeze
 
     # A namespace to prepend to all statsd calls. Defaults to no namespace.
     attr_reader :namespace
@@ -195,35 +272,60 @@ module Datadog
     # Maximum buffer size in bytes before it is flushed
     attr_reader :max_buffer_bytes
 
+    # Default sample rate
+    attr_reader :sample_rate
+
     # Connection
     attr_reader :connection
 
     # @param [String] host your statsd host
     # @param [Integer] port your statsd port
     # @option [String] namespace set a namespace to be prepended to every metric name
-    # @option [Array<String>] tags tags to be added to every metric
-    # @option [Loger] logger for debugging
+    # @option [Array<String>|Hash] tags tags to be added to every metric
+    # @option [Logger] logger for debugging
     # @option [Integer] max_buffer_bytes max bytes to buffer when using #batch
     # @option [String] socket_path unix socket path
+    # @option [Float] default sample rate if not overridden
     def initialize(
       host = nil,
       port = nil,
       namespace: nil,
       tags: nil,
-      max_buffer_bytes: 8192,
+      max_buffer_bytes: DEFAULT_BUFFER_SIZE,
       socket_path: nil,
-      logger: nil
+      logger: nil,
+      sample_rate: nil,
+      disable_telemetry: false
     )
-      @connection = Connection.new(host, port, socket_path, logger)
+      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
+
+      tags = tag_hash_to_array(tags) if tags.is_a? Hash
+      @tags = (tags || []).compact.map! {|tag| escape_tag_content(tag)}
+
+      # 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?
+
+      # 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)
+
+      if socket_path.nil?
+        @connection = UDPConnection.new(host, port, logger, @telemetry)
+      else
+        @connection = UDSConnection.new(socket_path, logger, @telemetry)
+      end
       @logger = logger
 
       @namespace = namespace
       @prefix = @namespace ? "#{@namespace}.".freeze : nil
 
-      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)}
+      @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
@@ -307,9 +409,6 @@ module Datadog
     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.
@@ -378,13 +477,14 @@ 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=EMPTY_OPTIONS)
+      @telemetry.service_checks += 1
       send_stat format_service_check(name, status, opts)
     end
 
@@ -395,9 +495,9 @@ 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"
@@ -407,6 +507,7 @@ 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)
     end
 
@@ -457,7 +558,11 @@ module Datadog
           escaped_message = escape_service_check_message(message)
           sc_string << "|m:#{escaped_message}"
         else
-          value = remove_pipes(opts[key])
+          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
@@ -467,13 +572,20 @@ module Datadog
     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.length},#{escaped_text.length}}:#{escaped_title}|#{escaped_text}".dup
+      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]
-          value = remove_pipes(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
@@ -483,12 +595,13 @@ module Datadog
         event_string_data << "|##{tags_string}"
       end
 
-      raise "Event #{title} payload is too big (more that 8KB), event discarded" if event_string_data.length > MAX_EVENT_SIZE
+      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
@@ -497,6 +610,10 @@ module Datadog
       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
@@ -516,8 +633,9 @@ module Datadog
     end
 
     def send_stats(stat, delta, type, opts=EMPTY_OPTIONS)
-      sample_rate = opts[:sample_rate] || 1
-      if sample_rate == 1 or rand < sample_rate
+      @telemetry.metrics += 1
+      sample_rate = opts[:sample_rate] || @sample_rate || 1
+      if sample_rate == 1 or rand <= sample_rate
         full_stat = ''.dup
         full_stat << @prefix if @prefix
 
@@ -543,17 +661,12 @@ module Datadog
           full_stat << '#'.freeze
           full_stat << tags_string
         end
-
         send_stat(full_stat)
       end
     end
 
     def send_stat(message)
-      if @batch.open?
-        @batch.add message
-      else
-        @connection.write(message)
-      end
+      @batch.open? ? @batch.add(message) : @connection.write(message)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dogstatsd-ruby
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.6.0
 platform: ruby
 authors:
 - Rein Henrichs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-08 00:00:00.000000000 Z
+date: 2020-01-20 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby DogStastd client
 email: code@datadoghq.com
@@ -21,10 +21,14 @@ files:
 - LICENSE.txt
 - README.md
 - lib/datadog/statsd.rb
-homepage: http://github.com/datadog/dogstatsd-ruby
+homepage: https://github.com/DataDog/dogstatsd-ruby
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/DataDog/dogstatsd-ruby/issues
+  changelog_uri: https://github.com/DataDog/dogstatsd-ruby/blob/v4.6.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/dogstatsd-ruby/4.6.0
+  source_code_uri: https://github.com/DataDog/dogstatsd-ruby/tree/v4.6.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -40,7 +44,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubyforge_project: 
+rubygems_version: 2.7.10
 signing_key: 
 specification_version: 4
 summary: A Ruby DogStatsd client