ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,84 @@
+require 'delayed/plugin'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/delayed_job/ext'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob plugin that instruments invoke_job hook
+      class Plugin < Delayed::Plugin
+        def self.instrument_invoke(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name(job),
+                                      on_error: configuration[:error_handler]) do |span|
+            set_sample_rate(span)
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(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
+        end
+
+        def self.instrument_enqueue(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          tracer.trace(Ext::SPAN_ENQUEUE, service: configuration[:client_service_name], resource: job_name(job)) do |span|
+            set_sample_rate(span)
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
+            span.set_tag(Ext::TAG_PRIORITY, job.priority)
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+
+            yield job
+          end
+        end
+
+        def self.flush(worker, &block)
+          yield worker
+
+          tracer.shutdown! if tracer && tracer.enabled
+        end
+
+        def self.configuration
+          Datadog.configuration[:delayed_job]
+        end
+
+        def self.tracer
+          configuration[:tracer]
+        end
+
+        def self.job_name(job)
+          # When DelayedJob is used through ActiveJob, we need to parse the payload differentely
+          # to get the actual job name
+          return job.payload_object.job_data['job_class'] if job.payload_object.respond_to?(:job_data)
+
+          job.name
+        end
+
+        def self.set_sample_rate(span)
+          # Set analytics sample rate
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+          end
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job, &method(:instrument_invoke))
+          lifecycle.around(:enqueue, &method(:instrument_enqueue))
+          lifecycle.around(:execute, &method(:flush))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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 :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          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,22 @@
+module Datadog
+  module Contrib
+    module Elasticsearch
+      # Elasticsearch integration constants
+      module Ext
+        APP = 'elasticsearch'.freeze
+        ENV_ENABLED = 'DD_TRACE_ELASTICSEARCH_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ELASTICSEARCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ELASTICSEARCH_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ELASTICSEARCH_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_ELASTICSEARCH_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'elasticsearch'.freeze
+        SPAN_QUERY = 'elasticsearch.query'.freeze
+        SPAN_TYPE_QUERY = 'elasticsearch'.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,39 @@
+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
+
+        MINIMUM_VERSION = Gem::Version.new('1.0.0')
+
+        register_as :elasticsearch, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['elasticsearch-transport'] \
+            && Gem.loaded_specs['elasticsearch-transport'].version
+        end
+
+        def self.loaded?
+          !defined?(::Elasticsearch::Transport).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        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,31 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/patcher'
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/integration'
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+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 target_version
+          Integration.version
+        end
+
         def patch
-          if !@patched && (defined?(::Elasticsearch::Transport::VERSION) && \
-                           Gem::Version.new(::Elasticsearch::Transport::VERSION) >= Gem::Version.new('1.0.0'))
-            begin
-              require 'uri'
-              require 'json'
-              require 'ddtrace/pin'
-              require 'ddtrace/ext/app_types'
-              require 'ddtrace/contrib/elasticsearch/quantize'
-
-              patch_elasticsearch_transport_client()
-
-              @patched = true
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Elastic Search integration: #{e}")
-            end
-          end
-          @patched
+          require 'uri'
+          require 'json'
+          require 'ddtrace/pin'
+          require 'ddtrace/contrib/elasticsearch/quantize'
+
+          patch_elasticsearch_transport_client
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -54,7 +40,13 @@ module Datadog
 
             def initialize(*args, &block)
               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: -> { Datadog.configuration[:elasticsearch][:tracer] }
+              )
               pin.onto(self)
               initialize_without_datadog(*args, &block)
             end
@@ -74,48 +66,55 @@ 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::Contrib::Elasticsearch::Ext::SPAN_TYPE_QUERY
 
                   # 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
+                  # Tag as an external peer service
+                  span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
+
+                  # Set analytics sample rate
+                  if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                    Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+                  end
+
+                  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]
+                    quantize_options = datadog_configuration[: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}"
                 rescue StandardError => e
-                  Datadog::Tracer.log.error(e.message)
+                  Datadog.logger.error(e.message)
                 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
+            def datadog_configuration
+              Datadog.configuration[:elasticsearch]
+            end
+          end
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Datadog
 
         def format_url(url)
           sanitize_fragment_with_id(url)
-            .gsub(/(?:[\d]+)/, PLACEHOLDER)
+            .gsub(/(?:\d+)/, PLACEHOLDER)
         end
 
         def format_body(body, options = {})
@@ -60,6 +60,7 @@ module Datadog
         # If JSON parsing fails, it prints fail_value.
         def reserialize_json(string, fail_value = PLACEHOLDER)
           return string unless block_given?
+
           begin
             JSON.dump(yield(JSON.parse(string)))
           rescue JSON::ParserError
@@ -72,7 +73,7 @@ module Datadog
         # This is meant as simple heuristic that attempts to detect if particular fragment
         # represents document Id. This is meant to reduce the cardinality in most frequent cases.
         def sanitize_fragment_with_id(url)
-          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^\?/\d]*[\d]+[^\?/]*)}, ID_PLACEHOLDER)
+          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^?/\d]*\d+[^?/]*)}, ID_PLACEHOLDER)
         end
       end
     end

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

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/ethon/ext'
+
+module Datadog
+  module Contrib
+    module Ethon
+      module Configuration
+        # Custom settings for the Ethon integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :distributed_tracing, default: true
+          option :service_name, default: Ext::SERVICE_NAME
+          option :split_by_domain, default: false
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/ethon/easy_patch.rb

@@ -0,0 +1,151 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/ext/integration'
+require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/ethon/ext'
+require 'ddtrace/contrib/http_annotation_helper'
+
+module Datadog
+  module Contrib
+    module Ethon
+      # Ethon EasyPatch
+      module EasyPatch
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          include Datadog::Contrib::HttpAnnotationHelper
+
+          def http_request(url, action_name, options = {})
+            load_datadog_configuration_for(url)
+            return super unless tracer_enabled?
+
+            # It's tricky to get HTTP method from libcurl
+            @datadog_method = action_name.to_s.upcase
+            super
+          end
+
+          def headers=(headers)
+            # Store headers to call this method again when span is ready
+            @datadog_original_headers = headers
+            super
+          end
+
+          def perform
+            load_datadog_configuration_for(url)
+            return super unless tracer_enabled?
+
+            datadog_before_request
+            super
+          end
+
+          def complete
+            return super unless tracer_enabled?
+
+            begin
+              response_options = mirror.options
+              response_code = (response_options[:response_code] || response_options[:code]).to_i
+              if response_code.zero?
+                return_code = response_options[:return_code]
+                message = return_code ? ::Ethon::Curl.easy_strerror(return_code) : 'unknown reason'
+                set_span_error_message("Request has failed: #{message}")
+              else
+                @datadog_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response_code)
+                if Datadog::Ext::HTTP::ERROR_RANGE.cover?(response_code)
+                  set_span_error_message("Request has failed with HTTP error: #{response_code}")
+                end
+              end
+            ensure
+              @datadog_span.finish
+              @datadog_span = nil
+            end
+            super
+          end
+
+          def reset
+            super
+          ensure
+            @datadog_span = nil
+            @datadog_method = nil
+            @datadog_original_headers = nil
+            @datadog_configuration = nil
+          end
+
+          def datadog_before_request(parent_span: nil)
+            load_datadog_configuration_for(url)
+            @datadog_span = datadog_configuration[:tracer].trace(
+              Ext::SPAN_REQUEST,
+              service: uri ? service_name(uri.host, datadog_configuration) : datadog_configuration[:service_name],
+              span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND
+            )
+            @datadog_span.parent = parent_span unless parent_span.nil?
+
+            datadog_tag_request
+
+            if datadog_configuration[:distributed_tracing]
+              @datadog_original_headers ||= {}
+              Datadog::HTTPPropagator.inject!(@datadog_span.context, @datadog_original_headers)
+              self.headers = @datadog_original_headers
+            end
+          end
+
+          def datadog_span_started?
+            instance_variable_defined?(:@datadog_span) && !@datadog_span.nil?
+          end
+
+          private
+
+          attr_reader :datadog_configuration
+
+          def datadog_tag_request
+            span = @datadog_span
+            method = Ext::NOT_APPLICABLE_METHOD
+            method = @datadog_method.to_s if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
+            span.resource = method
+            # Tag as an external peer service
+            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            this_uri = uri
+            return unless this_uri
+
+            span.set_tag(Datadog::Ext::HTTP::URL, this_uri.path)
+            span.set_tag(Datadog::Ext::HTTP::METHOD, method)
+            span.set_tag(Datadog::Ext::NET::TARGET_HOST, this_uri.host)
+            span.set_tag(Datadog::Ext::NET::TARGET_PORT, this_uri.port)
+          end
+
+          def set_span_error_message(message)
+            # Sets span error from message, in case there is no exception available
+            @datadog_span.status = Datadog::Ext::Errors::STATUS
+            @datadog_span.set_tag(Datadog::Ext::Errors::MSG, message)
+          end
+
+          def uri
+            URI.parse(url)
+          rescue URI::InvalidURIError
+          end
+
+          def load_datadog_configuration_for(host = :default)
+            @datadog_configuration = Datadog.configuration[:ethon, host]
+          end
+
+          def tracer_enabled?
+            datadog_configuration[:tracer].enabled
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+        end
+      end
+    end
+  end
+end