ddtrace 0.40.0 → 0.50.0

data/lib/ddtrace/contrib/configuration/resolver.rb

@@ -1,14 +1,79 @@
 module Datadog
   module Contrib
     module Configuration
-      # Resolves a configuration key to a Datadog::Contrib::Configuration:Settings object
+      # Resolves an integration-specific matcher to an associated
+      # object.
+      #
+      # Integrations that perform any configuration matching
+      # based on patterns might want to override this class
+      # to provide richer matching. For example, match configuration
+      # based on: HTTP request parameters, request headers,
+      # async queue name.
+      #
+      # When overriding this class, for simple use cases, only
+      # overriding `#parse_matcher` might suffice. See
+      # `#parse_matcher`'s documentation for more information.
       class Resolver
-        def resolve(key)
-          key
+        attr_reader :configurations
+
+        def initialize
+          @configurations = {}
+        end
+
+        # Adds a new `matcher`, associating with it a `value`.
+        #
+        # This `value` is returned when `#resolve` is called
+        # with a matching value for this matcher. When multiple
+        # matchers would match, `#resolve` returns the latest
+        # added one.
+        #
+        # The `matcher` can be transformed internally by the
+        # `#parse_matcher` method before being stored.
+        #
+        # The `value` can also be retrieved by calling `#get`
+        # with the same `matcher` added by this method.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @param [Object] value arbitrary value to be associated with `matcher`
+        def add(matcher, value)
+          @configurations[parse_matcher(matcher)] = value
+        end
+
+        # Retrieves the stored value for a `matcher`
+        # previously stored by `#add`.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @return [Object] previously stored `value` from `#add`, or `nil` if not found
+        def get(matcher)
+          @configurations[parse_matcher(matcher)]
+        end
+
+        # Matches an arbitrary value against the configured
+        # matchers previously set with `#add`.
+        #
+        # If multiple matchers would match, returns the latest one.
+        #
+        # @param [Object] value integration-specific value
+        # @return [Object] matching `value` configured at `#add`, or `nil` if none match
+        def resolve(value)
+          @configurations[value]
         end
 
-        def add(key)
-          key
+        protected
+
+        # Converts `matcher` into an appropriate key
+        # for the internal Hash storage.
+        #
+        # It's recommended to override this method,
+        # instead of the public methods, if the
+        # integration can simply convert both
+        # `matcher` (provided to `#add`) and `value`
+        # (provided to `#resolve`) to the same value.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @return [Object] processed matcher
+        def parse_matcher(matcher)
+          matcher
         end
       end
     end

data/lib/ddtrace/contrib/configuration/resolvers/pattern_resolver.rb

@@ -5,32 +5,32 @@ module Datadog
     module Configuration
       # Resolves a value to a configuration key
       module Resolvers
-        # Matches strings against Regexps.
-        class PatternResolver < Datadog::Contrib::Configuration::Resolver
-          def resolve(name)
+        # Matches Strings and Regexps against `object.to_s` objects
+        # and Procs against plain objects.
+        class PatternResolver < Contrib::Configuration::Resolver
+          def resolve(value)
+            return if configurations.empty?
+
             # Try to find a matching pattern
-            matching_pattern = patterns.find do |pattern|
-              # Rubocop incorrectly thinks assignment is done here...
-              # rubocop:disable Style/ConditionalAssignment
-              if pattern.is_a?(Proc)
-                pattern === name
-              else
-                pattern === name.to_s # Co-erce to string
-              end
+            _, config = configurations.reverse_each.find do |matcher, _|
+              matcher === if matcher.is_a?(Proc)
+                            value
+                          else
+                            value.to_s
+                          end
             end
 
-            # Return match or default
-            matching_pattern || :default
-          end
-
-          def add(pattern)
-            patterns << (pattern.is_a?(Regexp) || pattern.is_a?(Proc) ? pattern : pattern.to_s)
+            config
           end
 
-          private
+          protected
 
-          def patterns
-            @patterns ||= Set.new
+          def parse_matcher(matcher)
+            if matcher.is_a?(Regexp) || matcher.is_a?(Proc)
+              matcher
+            else
+              matcher.to_s
+            end
           end
         end
       end

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

@@ -1,4 +1,5 @@
 require 'ddtrace/configuration/base'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -7,6 +8,8 @@ module Datadog
       class Settings
         include Datadog::Configuration::Base
 
+        DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
         option :analytics_enabled, default: false
         option :analytics_sample_rate, default: 1.0
         option :enabled, default: true
@@ -14,7 +17,7 @@ module Datadog
         option :tracer do |o|
           o.delegate_to { Datadog.tracer }
           o.on_set do |_value|
-            log_deprecation_warning(:tracer)
+            log_deprecation_warning
           end
         end
 
@@ -41,11 +44,9 @@ module Datadog
           the correct tracer internally.
           ).freeze
 
-        include Datadog::Patcher # DEV includes #do_once here. We should move that logic to a generic component.
-
-        def log_deprecation_warning(method_name)
-          do_once(method_name) do
-            Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
+        def log_deprecation_warning
+          DEPRECATION_WARN_ONLY_ONCE.run do
+            Datadog.logger.warn("tracer:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
           end
         end
       end

data/lib/ddtrace/contrib/dalli/instrumentation.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/ext/integration'
 require 'ddtrace/ext/net'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/dalli/ext'
@@ -9,7 +10,7 @@ module Datadog
       # Instruments every interaction with the memcached server
       module Instrumentation
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # InstanceMethods - implementing instrumentation
@@ -20,6 +21,9 @@ module Datadog
               span.service = datadog_configuration[:service_name]
               span.span_type = Datadog::Contrib::Dalli::Ext::SPAN_TYPE_COMMAND
 
+              # 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])

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

@@ -17,45 +17,7 @@ module Datadog
         end
 
         def patch
-          add_pin!
-          ::Dalli::Server.send(:include, Instrumentation)
-        end
-
-        # DEPRECATED: Only kept for users still using `Dalli.datadog_pin` to configure.
-        #             Replaced by configuration API, i.e. `c.use :dalli`.
-        def add_pin!
-          DeprecatedPin
-            .new(
-              get_option(:service_name),
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::CACHE,
-              tracer: -> { get_option(:tracer) }
-            ).onto(::Dalli)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:dalli].get_option(option)
-        end
-
-        # Implementation of deprecated Pin, which raises warnings when accessed.
-        # To be removed when support for Datadog::Pin with Dalli is removed.
-        class DeprecatedPin < Datadog::Pin
-          include Datadog::DeprecatedPin
-
-          DEPRECATION_WARNING = %(
-            Use of Datadog::Pin with Dalli is DEPRECATED.
-            Upgrade to the configuration API using the migration guide here:
-            https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-          def service_name=(service_name)
-            Datadog.configuration[:dalli][:service_name] = service_name
-          end
-
-          def log_deprecation_warning(method_name)
-            do_once(method_name) do
-              Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
-            end
-          end
+          ::Dalli::Server.include(Instrumentation)
         end
       end
     end

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

@@ -23,6 +23,8 @@ module Datadog
           end
 
           option :service_name, default: Ext::SERVICE_NAME
+          option :client_service_name, default: Ext::CLIENT_SERVICE_NAME
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
         end
       end
     end

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

@@ -10,7 +10,9 @@ module Datadog
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'delayed_job'.freeze
+        CLIENT_SERVICE_NAME = 'delayed_job-client'.freeze
         SPAN_JOB = 'delayed_job'.freeze
+        SPAN_ENQUEUE = 'delayed_job.enqueue'.freeze
         TAG_ATTEMPTS = 'delayed_job.attempts'.freeze
         TAG_ID = 'delayed_job.id'.freeze
         TAG_PRIORITY = 'delayed_job.priority'.freeze

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

@@ -7,22 +7,12 @@ module Datadog
     module DelayedJob
       # DelayedJob plugin that instruments invoke_job hook
       class Plugin < Delayed::Plugin
-        def self.instrument(job, &block)
+        def self.instrument_invoke(job, &block)
           return block.call(job) unless tracer && tracer.enabled
 
-          # When DelayedJob is used through ActiveJob, we need to parse the payload differentely
-          # to get the actual job name
-          job_name = if job.payload_object.respond_to?(:job_data)
-                       job.payload_object.job_data['job_class']
-                     else
-                       job.name
-                     end
-
-          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name) do |span|
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
+          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)
@@ -37,6 +27,23 @@ module Datadog
           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
 
@@ -51,8 +58,24 @@ module Datadog
           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))
+          lifecycle.around(:invoke_job, &method(:instrument_invoke))
+          lifecycle.around(:enqueue, &method(:instrument_enqueue))
           lifecycle.around(:execute, &method(:flush))
         end
       end

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

@@ -1,5 +1,7 @@
+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'
@@ -77,6 +79,9 @@ module Datadog
                   params = JSON.generate(params) if params && !params.is_a?(String)
                   body = JSON.generate(body) if body && !body.is_a?(String)
 
+                  # 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])

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/easy_patch.rb

@@ -1,5 +1,6 @@
 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'
@@ -10,7 +11,7 @@ module Datadog
       # Ethon EasyPatch
       module EasyPatch
         def self.included(base)
-          base.send(:prepend, InstanceMethods)
+          base.prepend(InstanceMethods)
         end
 
         # InstanceMethods - implementing instrumentation
@@ -35,12 +36,14 @@ module Datadog
           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
@@ -98,20 +101,21 @@ module Datadog
 
           def datadog_tag_request
             span = @datadog_span
-            method = 'N/A'
-            if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-              method = @datadog_method.to_s
-            end
+            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?
 
-            return unless uri
-            span.set_tag(Datadog::Ext::HTTP::URL, uri.path)
+            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, uri.host)
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, uri.port)
+            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)
@@ -122,7 +126,6 @@ module Datadog
 
           def uri
             URI.parse(url)
-          # rubocop:disable Lint/HandleExceptions
           rescue URI::InvalidURIError
           end