ruby-dogstatsd 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c11b919fdc1a1987265e34fece499d93e3f24882460c411f1659701e0921494
+  data.tar.gz: 99db0d36302f050f00afc5266eeb40832507f801b20c3f2fc76b07bfbd27b6d9
+SHA512:
+  metadata.gz: 29103c292ddada1d9c8c70ff7660af08466aa7bff87fb69f7495bcc17bf8a58a74b2c5e3f41708c0ebfe1ff5b2997cc7f8bca42a9c7e8ce41049196b4b181ec0
+  data.tar.gz: cf164dc679d1782cca7979810f16980fcda0a53f04a2328f7f27df14d96a11f58b28541b4cc6e3dffe9e3411a7dca53bc06d80d4f330e3d4a404f94f90cc0f62

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+ruby '2.5.1'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    ruby-dogstatsd (0.1.0)
+      dogstatsd-ruby (>= 2.0.0)
+      sidekiq
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.5)
+    connection_pool (2.2.1)
+    diff-lcs (1.3)
+    dogstatsd-ruby (3.3.0)
+    rack (2.0.5)
+    rack-protection (2.0.1)
+      rack
+    rake (12.3.1)
+    redis (4.0.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    sidekiq (5.1.3)
+      concurrent-ruby (~> 1.0)
+      connection_pool (~> 2.2, >= 2.2.0)
+      rack-protection (>= 1.5.0)
+      redis (>= 3.3.5, < 5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  rack
+  rake
+  rspec (~> 3.0)
+  ruby-dogstatsd!
+  sidekiq
+
+RUBY VERSION
+   ruby 2.5.1p57
+
+BUNDLED WITH
+   1.16.1

data/lib/datadog-client.rb

@@ -0,0 +1 @@
+require "ruby/reporters/datadog"

data/lib/rails-middleware-datadog.rb

@@ -0,0 +1 @@
+require "rails/middleware/datadog"

data/lib/rails/middleware/datadog.rb

@@ -0,0 +1,46 @@
+module Rails
+  module Middleware
+    class Datadog      
+      def initialize(app, opts={})
+        @app = app
+
+        statsd_host  = opts[:statsd_host] || "localhost"
+        statsd_port  = opts[:statsd_port] || 8125
+        namespace    = opts[:statsd_prefix] || nil
+
+        @statsd = opts[:statsd] || Ruby::Reporters::Datadog.new(opts)
+      end
+    
+      def call(env)
+        start_request_time = Time.now
+        status, header, body = @app.call(env)
+        end_request_time = Time.now
+
+        report_to_statsd(start_request_time, end_request_time, env, status)        
+
+        [status, header, body]
+      end
+
+      private
+      def extract_path_from_request(env)
+        env['PATH_INFO']
+      end
+
+      def extract_method_from_request(env)
+        env['REQUEST_METHOD']
+      end
+
+      def compute_elapsed_time_ms(start_request_time, end_request_time)
+        (end_request_time - start_request_time) * 1000
+      end
+
+      def report_to_statsd(start_request_time, end_request_time, env, status)
+        elapsed_time_ms = compute_elapsed_time_ms(start_request_time, end_request_time)
+        request_method = extract_method_from_request(env)
+        path = extract_path_from_request(env)
+
+        @statsd.response_time_ms(path, request_method, status, elapsed_time_ms)
+      end
+    end
+  end
+end

data/lib/ruby/reporters/datadog.rb

@@ -0,0 +1,58 @@
+require 'datadog/statsd'
+
+module Ruby
+  module Reporters
+    class Datadog
+      attr_reader :statsd, :response_time_metric_name, :default_http_tags
+          
+      def initialize(opts={})
+        statsd_host                 = opts[:statsd_host] || "localhost"
+        statsd_port                 = opts[:statsd_port] || 8125
+        namespace                   = opts[:statsd_prefix] || nil
+        
+        @default_http_tags          = ['type:http']
+        @response_time_metric_name  = 'response_time_ms'
+        
+        @statsd = opts[:statsd] || ::Datadog::Statsd.new(statsd_host, statsd_port, namespace: namespace)
+      end
+      
+      def response_time_ms(path, method, status, value)
+        tags = [
+          "route:#{method.upcase} #{path}",
+          "status:#{status}",
+          "error:#{from_status_to_error(status)}"
+        ]
+
+        histogram(response_time_metric_name, value, default_http_tags | tags)
+      end
+
+      def gauge(metric_name, value, tags)
+        statsd.gauge(
+          metric_name,
+          value,
+          tags: tags
+        )
+      end
+
+      def increment(metric_name, tags)
+        statsd.increment(
+          metric_name,
+          tags: tags
+        )
+      end
+
+      def histogram(metric_name, value, tags)
+        statsd.histogram(
+          metric_name,
+          value,
+          tags:tags
+        )
+      end
+    
+      private
+      def from_status_to_error(status)
+        status.to_i < 400 ? "false" : "true"
+      end
+    end
+  end
+end

data/lib/sidekiq-middleware-datadog.rb

@@ -0,0 +1 @@
+require "sidekiq/middleware/datadog"

data/lib/sidekiq/middleware/datadog.rb

@@ -0,0 +1,109 @@
+require 'datadog/statsd'
+require 'socket'
+require 'sidekiq'
+
+module Sidekiq
+  module Middleware
+    class Datadog
+      attr_accessor :hostname, :statsd_host, :statsd_port, :statsd, :xalala 
+      # Configure and install datadog instrumentation. Example:
+      #
+      #   Sidekiq.configure_server do |config|
+      #     config.server_middleware do |chain|
+      #       chain.add Sidekiq::Middleware::Datadog
+      #     end
+      #   end
+      #
+      
+      def initialize(opts)
+        statsd_host   = opts[:statsd_host] || "localhost"
+        statsd_port   = (opts[:statsd_port] || 8125).to_i
+        prefix        = opts[:prefix] || ""
+        
+        @metric_name  = opts[:metric_name] || "worker"
+        @statsd       = opts[:statsd] || ::Datadog::Statsd.new(statsd_host, statsd_port, namespace: prefix)
+        @tags         = opts[:tags] || []
+
+        enrich_global_tags()
+      end
+
+      def call(worker, job, queue, *)
+        start = Time.now
+        
+        begin
+          yield
+          record(worker, job, queue, start)
+        rescue => e
+          record(worker, job, queue, start, e)
+          raise
+        end
+      end
+
+      private
+      def enrich_global_tags
+        env = Sidekiq.options[:environment] || ENV['RACK_ENV']
+
+        if env && @tags.none? {|t| t =~ /^env\:/ }
+          @tags.push("env:#{ENV['RACK_ENV']}")
+        end
+      end
+
+      def pre_proccess_tags(tags, worker, job, name, queue, error)
+        tags = @tags.map do |tag|
+          case tag 
+          when String 
+            then tag 
+          when Proc 
+            then tag.call(worker, job, queue, error) 
+          end
+        end
+
+        tags.push "name:#{name}"
+        tags.push "queue:#{queue}" if queue 
+
+        if error
+          kind = replace_hifen_to_underscore(error.class.name.sub(/Error$/, ''))
+          tags.push "error:true", "error_kind:#{kind}"
+        else
+            tags.push "error:false"
+        end
+       
+        tags.compact
+      end
+
+
+      def record(worker, job, queue, start, error = nil)
+        end_time = Time.now
+
+        elapsed_time_ms   = compute_elapsed_time_ms(end_time, start)
+        name = replace_hifen_to_underscore(job['wrapped'] || worker.class.to_s)
+        tags = pre_proccess_tags(@tags, worker, job, name, queue, error)
+        
+        report_queue_processing_time(elapsed_time_ms, tags)
+        report_queue_length(queue, tags)
+      end
+
+      def replace_hifen_to_underscore(word)
+        word = word.to_s.gsub(/::/, '/')
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+
+        word.downcase
+      end
+
+      def compute_elapsed_time_ms(start_time, end_time)
+        (end_time - start_time) * 1000
+      end
+
+      def report_queue_length(queue_name, tags)
+        queue = queue_name ? Sidekiq::Queues[queue_name] : Sidekiq::Queues["default"]
+        @statsd.gauge "#{@metric_name}.queue_size", queue.size, :tags => tags
+      end
+
+      def report_queue_processing_time(value, tags)
+        @statsd.timing "#{@metric_name}.run_time_ms", value, :tags => tags
+      end
+    end
+  end
+end

data/lib/sinatra-middleware-datadog.rb

@@ -0,0 +1 @@
+require "sinatra/middleware/datadog"

data/lib/sinatra/middleware/datadog.rb

@@ -0,0 +1,8 @@
+require "rails/middleware/datadog"
+
+module Sinatra
+  module Middleware
+    class Datadog < Rails::Middleware::Datadog
+    end
+  end
+end

data/ruby-dogstatsd.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+    spec.name          = "ruby-dogstatsd"
+    spec.version       = "0.0.3"
+    spec.authors       = ["Top Free Games"]
+    spec.email         = ["backend@tfgco.com"]
+    spec.description   = %q{Rails middleware report metrics to Datadog}
+    spec.summary       = %q{Report basic metrics to datadog}
+    spec.homepage      = "https://git.topfreegames.com/topfreegames/rails-datadog-middleware"
+    spec.license       = "MIT"
+  
+    spec.files         = `git ls-files`.split($/)
+    spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+    spec.test_files    = spec.files.grep(%r{^(spec)/})
+    spec.require_paths = ["lib"]
+  
+    spec.add_runtime_dependency(%q<dogstatsd-ruby>, ">= 2.0.0")
+    spec.add_runtime_dependency(%q<sidekiq>)
+
+    spec.add_development_dependency(%q<rake>)
+    spec.add_development_dependency(%q<rack>)
+    spec.add_development_dependency(%q<bundler>)
+    spec.add_development_dependency(%q<rspec>, "~> 3.0")
+    spec.add_development_dependency(%q<sidekiq>)
+  end

data/spec/rails/middleware/datadog_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'sidekiq/testing'
+require 'rack'
+
+describe Rails::Middleware::Datadog do
+  class Datadog::Statsd
+    attr_accessor :socket
+  end
+
+  class Rails::Middleware::Datadog
+    def compute_elapsed_time_ms(start_request_time, end_request_time)
+      10
+    end
+  end
+
+  describe 'teste reporting pre-defined metrics' do  
+    context 'using rails middleware with dafault statsd host and port' do
+      before(:all) do
+        @statsd = Ruby::Reporters::Datadog.new(namespace: "dd_statsd_test")
+        @statsd.statsd.socket = Mock::FakeUDPSocket.new
+      end
+
+      before(:each) do
+        @statsd.statsd.socket.buffer.clear()
+      end
+      
+      context 'successful request' do
+        let(:app) { lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['OK']]} }
+        let(:middleware) { Rails::Middleware::Datadog.new(app, {statsd: @statsd})  }
+
+        it 'should report a response_time_ms with tag error:false and other tags' do
+          middleware.call env_for('http://sniper3d.tfgco.com/players')
+
+          expect(@statsd.statsd.socket.buffer).to eq([[
+            "response_time_ms:10|h|#type:http,route:GET /players,status:200,error:false"
+            ]])
+        end
+      end
+
+      context 'failed, returning 404' do
+        let(:app) { lambda {|env| [404, {'Content-Type' => 'text/plain'}, ['Not Found']]} }
+        let(:middleware) { Rails::Middleware::Datadog.new(app, {statsd: @statsd})  }
+
+        it 'should report a response_time_ms with tag error:false and other tags' do
+          middleware.call env_for('http://sniper3d.tfgco.com/players/xablau')
+
+          expect(@statsd.statsd.socket.buffer).to eq([[
+            "response_time_ms:10|h|#type:http,route:GET /players/xablau,status:404,error:true"
+            ]])
+        end
+      end
+
+      context 'failed, returning 503' do
+        let(:app) { lambda {|env| [503, {'Content-Type' => 'text/plain'}, ['Internal Server Error']]} }
+        let(:middleware) { Rails::Middleware::Datadog.new(app, {statsd: @statsd})  }
+
+        it 'should report a response_time_ms with tag error:false and other tags' do
+          middleware.call env_for('http://sniper3d.tfgco.com/players/xablau')
+
+          expect(@statsd.statsd.socket.buffer).to eq([[
+            "response_time_ms:10|h|#type:http,route:GET /players/xablau,status:503,error:true"
+            ]])
+        end
+      end
+    end
+  end
+
+  def env_for(url, opts={})
+    Rack::MockRequest.env_for(url, opts)
+  end
+end

data/spec/ruby/reporters/datadog_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'sidekiq/testing'
+
+describe Ruby::Reporters::Datadog do
+  class Datadog::Statsd
+    attr_accessor :socket
+  end
+
+  describe 'report metrics to dd-statsd' do  
+    context 'using default values for host and port' do
+      before(:all) do
+        @statsd = Ruby::Reporters::Datadog.new(namespace: "dd_statsd_test")
+        @statsd.statsd.socket = Mock::FakeUDPSocket.new
+      end
+
+      before(:each) do
+        @statsd.statsd.socket.buffer.clear()
+      end
+
+      context 'exploring response_time_ms' do
+        context 'request failed, returning 404' do
+          it 'should report a response_time_ms with tag error:true' do
+            @statsd.response_time_ms("/root", "get", 404, 1230)
+
+            expect(@statsd.statsd.socket.buffer).to eq([[
+              "response_time_ms:1230|h|#type:http,route:GET /root,status:404,error:true"
+              ]])
+          end
+        end
+
+        context 'request failed, returning 503' do
+          it 'should report a response_time_ms with tag error:true' do
+            @statsd.response_time_ms("/root", "get", 503, 1230)
+
+            expect(@statsd.statsd.socket.buffer).to eq([[
+              "response_time_ms:1230|h|#type:http,route:GET /root,status:503,error:true"
+              ]])
+          end
+        end
+
+        context 'request succeeded, returning 200' do
+          it 'should report a response_time_ms with tag error:false' do
+            @statsd.response_time_ms("/root", "get", 200, 1230)
+
+            expect(@statsd.statsd.socket.buffer).to eq([[
+              "response_time_ms:1230|h|#type:http,route:GET /root,status:200,error:false"
+              ]])
+          end
+        end
+      end
+
+      context 'exploring native calls' do
+        it 'should report a gauge' do
+          @statsd.gauge("number-of-pitayas", 342, ['status:ready-for-consumption'])
+
+          expect(@statsd.statsd.socket.buffer).to eq([[
+            "number-of-pitayas:342|g|#status:ready-for-consumption"
+            ]])
+        end
+
+        it 'should increment a counter' do
+          @statsd.increment("number-of-pitayas", ['kind:juice'])
+
+          expect(@statsd.statsd.socket.buffer).to eq([[
+            "number-of-pitayas:1|c|#kind:juice"
+            ]])
+        end
+      end
+    end
+  end
+end

data/spec/sidekiq/datadog_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'sidekiq/testing'
+
+Sidekiq::Testing.fake!
+
+describe Sidekiq::Middleware::Datadog do
+  class Datadog::Statsd
+    attr_accessor :socket
+  end
+
+  class Sidekiq::Middleware::Datadog
+    def compute_elapsed_time_ms(start_time, end_time)
+      21
+    end
+  end
+
+  describe 'reports metrics to dd-statsd when middleware gets called' do  
+    before(:all)  do
+      @statsd = Datadog::Statsd.new("localhost", 8125)
+      @statsd.socket = Mock::FakeUDPSocket.new
+
+      Sidekiq::Testing.server_middleware do |chain|
+        chain.add Sidekiq::Middleware::Datadog, hostname: "localhost", statsd: @statsd, tags: ["custom:tag", lambda{|w, *| "worker:0" }] 
+      end
+    end
+
+    context 'enqueueing all two jobs' do
+      let(:worker) { Mock::Worker.new }
+
+      before(:context) do
+        @jobs = ['test-job-1', 'test-job-2']
+        @jobs.each { | job | Mock::Worker.perform_async(job) }
+      end
+
+      it 'should have two jobs at the queue' do
+        expect(Sidekiq::Queues["default"].size).to eq(@jobs.size)
+      end
+
+      context 'middleware gets called' do
+        before(:all) do
+          Mock::Worker.drain  
+        end
+
+        it 'should have 0 jobs at the queue' do
+          expect(Sidekiq::Queues["default"].size).to eq(0)        
+        end
+
+        it 'should publish metrics from the fisrt job to dogstatd' do
+          expect(@statsd.socket.buffer[0]).to eq([
+            "worker.run_time_ms:21|ms|#custom:tag,worker:0,env:test,name:mock/worker,queue:default,error:false"
+          ])
+
+          expect(@statsd.socket.buffer[1]).to eq([
+            "worker.queue_size:1|g|#custom:tag,worker:0,env:test,name:mock/worker,queue:default,error:false"
+          ])
+        end
+
+        it 'should publish metrics from the second job to dogstatd' do
+          expect(@statsd.socket.buffer[0]).to eq([
+            "worker.run_time_ms:21|ms|#custom:tag,worker:0,env:test,name:mock/worker,queue:default,error:false"
+          ])
+
+          expect(@statsd.socket.buffer[1]).to eq([
+            "worker.queue_size:1|g|#custom:tag,worker:0,env:test,name:mock/worker,queue:default,error:false"
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+ENV['RACK_ENV'] ||= 'test'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'sidekiq'
+require 'sidekiq-middleware-datadog'
+require 'rails-middleware-datadog'
+require 'sinatra-middleware-datadog'
+require 'datadog-client'
+
+module Mock
+  class Worker
+    include Sidekiq::Worker
+    def perform(name)
+    end
+  end
+
+  class FakeUDPSocket
+    attr_reader :buffer
+
+    def initialize
+      @buffer = []
+    end
+  
+    def send(message, *)
+      @buffer.push [message]
+    end
+  
+    def recv
+      @buffer.shift
+    end
+  
+    def to_s
+      inspect
+    end
+  
+    def inspect
+      "<FakeUDPSocket: #{@buffer.inspect}>"
+    end
+  end
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: ruby-dogstatsd
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Top Free Games
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dogstatsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails middleware report metrics to Datadog
+email:
+- backend@tfgco.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/datadog-client.rb
+- lib/rails-middleware-datadog.rb
+- lib/rails/middleware/datadog.rb
+- lib/ruby/reporters/datadog.rb
+- lib/sidekiq-middleware-datadog.rb
+- lib/sidekiq/middleware/datadog.rb
+- lib/sinatra-middleware-datadog.rb
+- lib/sinatra/middleware/datadog.rb
+- ruby-dogstatsd.gemspec
+- spec/rails/middleware/datadog_spec.rb
+- spec/ruby/reporters/datadog_spec.rb
+- spec/sidekiq/datadog_spec.rb
+- spec/sinatra/datadog_spec.rb
+- spec/spec_helper.rb
+homepage: https://git.topfreegames.com/topfreegames/rails-datadog-middleware
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Report basic metrics to datadog
+test_files:
+- spec/rails/middleware/datadog_spec.rb
+- spec/ruby/reporters/datadog_spec.rb
+- spec/sidekiq/datadog_spec.rb
+- spec/sinatra/datadog_spec.rb
+- spec/spec_helper.rb