ddtrace 0.16.1 → 0.17.0

data/lib/ddtrace/contrib/delayed_job/ext.rb

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob integration constants
+      module Ext
+        APP = 'delayed_job'.freeze
+        SERVICE_NAME = 'delayed_job'.freeze
+
+        SPAN_JOB = 'delayed_job'.freeze
+
+        TAG_ATTEMPTS = 'delayed_job.attempts'.freeze
+        TAG_ID = 'delayed_job.id'.freeze
+        TAG_PRIORITY = 'delayed_job.priority'.freeze
+        TAG_QUEUE = 'delayed_job.queue'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/integration.rb

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/delayed_job/configuration/settings'
+require 'ddtrace/contrib/delayed_job/patcher'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # Description of DelayedJob integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :delayed_job
+
+        def self.version
+          Gem.loaded_specs['delayed_job'] && Gem.loaded_specs['delayed_job'].version
+        end
+
+        def self.present?
+          super && defined?(::Delayed)
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/patcher.rb

@@ -1,39 +1,32 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+
 module Datadog
   module Contrib
     module DelayedJob
-      # DelayedJob integration
+      # Patcher enables patching of 'delayed_job' module.
       module Patcher
-        include Base
-        register_as :delayed_job
-
-        option :service_name, default: 'delayed_job'.freeze
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
-        class << self
-          def patch
-            return @patched if patched? || !defined?(::Delayed)
+        module_function
 
-            require 'ddtrace/ext/app_types'
-            require_relative 'plugin'
-
-            add_instrumentation(::Delayed::Worker)
-            @patched = true
-          rescue => e
-            Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
-            @patched
-          end
+        def patched?
+          done?(:delayed_job)
+        end
 
-          def patched?
-            @patched
+        def patch
+          do_once(:delayed_job) do
+            begin
+              require 'ddtrace/contrib/delayed_job/plugin'
+              add_instrumentation(::Delayed::Worker)
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
+            end
           end
+        end
 
-          private
-
-          def add_instrumentation(klass)
-            klass.plugins << Plugin
-          end
+        def add_instrumentation(klass)
+          klass.plugins << Plugin
         end
       end
     end

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -1,4 +1,5 @@
 require 'delayed/plugin'
+require 'ddtrace/contrib/delayed_job/ext'
 
 module Datadog
   module Contrib
@@ -8,12 +9,12 @@ module Datadog
         def self.instrument(job, &block)
           return block.call(job) unless tracer && tracer.enabled
 
-          tracer.trace('delayed_job'.freeze, service: configuration[:service_name], resource: job.name) do |span|
-            span.set_tag('delayed_job.id'.freeze, job.id)
-            span.set_tag('delayed_job.queue'.freeze, job.queue) if job.queue
-            span.set_tag('delayed_job.priority'.freeze, job.priority)
-            span.set_tag('delayed_job.attempts'.freeze, job.attempts)
-            span.span_type = Ext::AppTypes::WORKER
+          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job.name) do |span|
+            span.set_tag(Ext::TAG_ID, job.id)
+            span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
+            span.set_tag(Ext::TAG_PRIORITY, job.priority)
+            span.set_tag(Ext::TAG_ATTEMPTS, job.attempts)
+            span.span_type = Datadog::Ext::AppTypes::WORKER
 
             yield job
           end

data/lib/ddtrace/contrib/elasticsearch/configuration/settings.rb

@@ -0,0 +1,16 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/elasticsearch/ext'
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      module Configuration
+        # Custom settings for the Elasticsearch integration
+        class Settings < Contrib::Configuration::Settings
+          option :quantize, default: {}
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/elasticsearch/ext.rb

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Elasticsearch integration constants
+      module Ext
+        APP = 'elasticsearch'.freeze
+        SERVICE_NAME = 'elasticsearch'.freeze
+
+        SPAN_QUERY = 'elasticsearch.query'.freeze
+
+        TAG_BODY = 'elasticsearch.body'.freeze
+        TAG_METHOD = 'elasticsearch.method'.freeze
+        TAG_PARAMS = 'elasticsearch.params'.freeze
+        TAG_URL = 'elasticsearch.url'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/elasticsearch/integration.rb

@@ -0,0 +1,37 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/elasticsearch/configuration/settings'
+require 'ddtrace/contrib/elasticsearch/patcher'
+
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Description of Elasticsearch integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :elasticsearch, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['elasticsearch-transport'] \
+            && Gem.loaded_specs['elasticsearch-transport'].version
+        end
+
+        def self.present?
+          super && defined?(::Elasticsearch::Transport)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('1.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/elasticsearch/patcher.rb

@@ -1,45 +1,34 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/elasticsearch/ext'
 
 module Datadog
   module Contrib
     module Elasticsearch
-      URL = 'elasticsearch.url'.freeze
-      METHOD = 'elasticsearch.method'.freeze
-      PARAMS = 'elasticsearch.params'.freeze
-      BODY = 'elasticsearch.body'.freeze
-
-      SERVICE = 'elasticsearch'.freeze
-
-      # Patcher enables patching of 'elasticsearch/transport' module.
+      # Patcher enables patching of 'elasticsearch' module.
       module Patcher
-        include Base
-        register_as :elasticsearch, auto_patch: true
-        option :service_name, default: SERVICE
-        option :quantize, default: {}
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        # patch applies our patch if needed
+        def patched?
+          done?(:elasticsearch)
+        end
+
         def patch
-          if !@patched && (defined?(::Elasticsearch::Transport::VERSION) && \
-                           Gem::Version.new(::Elasticsearch::Transport::VERSION) >= Gem::Version.new('1.0.0'))
+          do_once(:elasticsearch) do
             begin
               require 'uri'
               require 'json'
               require 'ddtrace/pin'
-              require 'ddtrace/ext/app_types'
               require 'ddtrace/contrib/elasticsearch/quantize'
 
-              patch_elasticsearch_transport_client()
-
-              @patched = true
+              patch_elasticsearch_transport_client
             rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Elastic Search integration: #{e}")
+              Datadog::Tracer.log.error("Unable to apply Elasticsearch integration: #{e}")
             end
           end
-          @patched
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -53,8 +42,15 @@ module Datadog
             end
 
             def initialize(*args, &block)
+              tracer = Datadog.configuration[:elasticsearch][:tracer]
               service = Datadog.configuration[:elasticsearch][:service_name]
-              pin = Datadog::Pin.new(service, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
+
+              pin = Datadog::Pin.new(
+                service,
+                app: Datadog::Contrib::Elasticsearch::Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: tracer
+              )
               pin.onto(self)
               initialize_without_datadog(*args, &block)
             end
@@ -74,29 +70,29 @@ module Datadog
 
               url = full_url.path
               response = nil
-              pin.tracer.trace('elasticsearch.query') do |span|
+              pin.tracer.trace(Datadog::Contrib::Elasticsearch::Ext::SPAN_QUERY) do |span|
                 begin
                   connection = transport.connections.first
                   host = connection.host[:host] if connection
                   port = connection.host[:port] if connection
 
                   span.service = pin.service
-                  span.span_type = Ext::AppTypes::DB
+                  span.span_type = Datadog::Ext::AppTypes::DB
 
                   # load JSON for the following fields unless they're already strings
                   params = JSON.generate(params) if params && !params.is_a?(String)
                   body = JSON.generate(body) if body && !body.is_a?(String)
 
-                  span.set_tag(METHOD, method)
-                  span.set_tag(URL, url)
-                  span.set_tag(PARAMS, params) if params
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_METHOD, method)
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_URL, url)
+                  span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_PARAMS, params) if params
                   if body
                     quantize_options = Datadog.configuration[:elasticsearch][:quantize]
                     quantized_body = Datadog::Contrib::Elasticsearch::Quantize.format_body(body, quantize_options)
-                    span.set_tag(BODY, quantized_body)
+                    span.set_tag(Datadog::Contrib::Elasticsearch::Ext::TAG_BODY, quantized_body)
                   end
-                  span.set_tag('out.host', host) if host
-                  span.set_tag('out.port', port) if port
+                  span.set_tag(Datadog::Ext::NET::TARGET_HOST, host) if host
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, port) if port
 
                   quantized_url = Datadog::Contrib::Elasticsearch::Quantize.format_url(url)
                   span.resource = "#{method} #{quantized_url}"
@@ -105,18 +101,13 @@ module Datadog
                 ensure
                   # the call is still executed
                   response = perform_request_without_datadog(*args)
-                  span.set_tag('http.status_code', response.status)
+                  span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
                 end
               end
               response
             end
           end
         end
-
-        # patched? tells wether patch has been successfully applied
-        def patched?
-          @patched
-        end
       end
     end
   end

data/lib/ddtrace/contrib/excon/configuration/settings.rb

@@ -0,0 +1,18 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/excon/ext'
+
+module Datadog
+  module Contrib
+    module Excon
+      module Configuration
+        # Custom settings for the Excon integration
+        class Settings < Contrib::Configuration::Settings
+          option :distributed_tracing, default: false
+          option :error_handler, default: nil
+          option :service_name, default: Ext::SERVICE_NAME
+          option :split_by_domain, default: false
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/excon/ext.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Contrib
+    module Excon
+      # Excon integration constants
+      module Ext
+        APP = 'excon'.freeze
+        SERVICE_NAME = 'excon'.freeze
+
+        SPAN_REQUEST = 'excon.request'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/excon/integration.rb

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/excon/configuration/settings'
+require 'ddtrace/contrib/excon/patcher'
+
+module Datadog
+  module Contrib
+    module Excon
+      # Description of Excon integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :excon
+
+        def self.version
+          Gem.loaded_specs['excon'] && Gem.loaded_specs['excon'].version
+        end
+
+        def self.present?
+          super && defined?(::Excon)
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/excon/middleware.rb

@@ -3,26 +3,26 @@ require 'ddtrace/ext/http'
 require 'ddtrace/ext/net'
 require 'ddtrace/ext/distributed'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/excon/ext'
 
 module Datadog
   module Contrib
     module Excon
       # Middleware implements an excon-middleware for ddtrace instrumentation
       class Middleware < ::Excon::Middleware::Base
-        SPAN_NAME = 'excon.request'.freeze
         DEFAULT_ERROR_HANDLER = lambda do |response|
-          Ext::HTTP::ERROR_RANGE.cover?(response[:status])
+          Datadog::Ext::HTTP::ERROR_RANGE.cover?(response[:status])
         end
 
         def initialize(stack, options = {})
           super(stack)
-          @options = Datadog.configuration[:excon].merge(options)
+          @options = Datadog.configuration[:excon].to_h.merge(options)
         end
 
         def request_call(datum)
           begin
             unless datum.key?(:datadog_span)
-              tracer.trace(SPAN_NAME).tap do |span|
+              tracer.trace(Ext::SPAN_REQUEST).tap do |span|
                 datum[:datadog_span] = span
                 annotate!(span, datum)
                 propagate!(span, datum) if distributed_tracing?
@@ -97,11 +97,11 @@ module Datadog
         def annotate!(span, datum)
           span.resource = datum[:method].to_s.upcase
           span.service = service_name(datum)
-          span.span_type = Ext::HTTP::TYPE
-          span.set_tag(Ext::HTTP::URL, datum[:path])
-          span.set_tag(Ext::HTTP::METHOD, datum[:method].to_s.upcase)
-          span.set_tag(Ext::NET::TARGET_HOST, datum[:host])
-          span.set_tag(Ext::NET::TARGET_PORT, datum[:port].to_s)
+          span.span_type = Datadog::Ext::HTTP::TYPE
+          span.set_tag(Datadog::Ext::HTTP::URL, datum[:path])
+          span.set_tag(Datadog::Ext::HTTP::METHOD, datum[:method].to_s.upcase)
+          span.set_tag(Datadog::Ext::NET::TARGET_HOST, datum[:host])
+          span.set_tag(Datadog::Ext::NET::TARGET_PORT, datum[:port].to_s)
         end
 
         def handle_response(datum)
@@ -114,7 +114,7 @@ module Datadog
                 if error_handler.call(response)
                   span.set_error(["Error #{response[:status]}", response[:body]])
                 end
-                span.set_tag(Ext::HTTP::STATUS_CODE, response[:status])
+                span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response[:status])
               end
               span.set_error(datum[:error]) if datum.key?(:error)
               span.finish