ddtrace 0.43.0 → 0.48.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,31 +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|
-              if pattern.is_a?(Proc)
-                (pattern === name)
-              else
-                (pattern === name.to_s) ||
-                  (pattern == name) # Only required during configuration time.
-              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
-          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/cucumber/configuration/settings.rb

@@ -12,16 +12,6 @@ module Datadog
             o.lazy
           end
 
-          option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, true) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-            o.lazy
-          end
-
           option :service_name do |o|
             o.default { Datadog.configuration.service || Ext::SERVICE_NAME }
             o.lazy

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

@@ -4,8 +4,6 @@ module Datadog
       # Cucumber integration constants
       module Ext
         APP = 'cucumber'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_CUCUMBER_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_CUCUMBER_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ENABLED = 'DD_TRACE_CUCUMBER_ENABLED'.freeze
         ENV_OPERATION_NAME = 'DD_TRACE_CUCUMBER_OPERATION_NAME'.freeze
         FRAMEWORK = 'cucumber'.freeze

data/lib/ddtrace/contrib/cucumber/formatter.rb

@@ -9,10 +9,8 @@ module Datadog
     module Cucumber
       # Defines collection of instrumented Cucumber events
       class Formatter
-        attr_reader :config
+        attr_reader :config, :current_feature_span, :current_step_span
         private :config
-
-        attr_reader :current_feature_span, :current_step_span
         private :current_feature_span, :current_step_span
 
         def initialize(config)
@@ -43,17 +41,13 @@ module Datadog
           @current_feature_span.set_tag(Datadog::Ext::Test::TAG_TYPE, Ext::TEST_TYPE)
           @current_feature_span.set_tag(Datadog::Ext::Test::TAG_SPAN_KIND, Datadog::Ext::AppTypes::TEST)
 
-          # Set analytics sample rate
-          if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-            Datadog::Contrib::Analytics.set_sample_rate(@current_feature_span, configuration[:analytics_sample_rate])
-          end
-
           # Measure service stats
           Contrib::Analytics.set_measured(@current_feature_span)
         end
 
         def on_test_case_finished(event)
           return if @current_feature_span.nil?
+
           @current_feature_span.status = 1 if event.result.failed?
           @current_feature_span.set_tag(Datadog::Ext::Test::TAG_STATUS, status_from_result(event.result))
           @current_feature_span.finish
@@ -69,9 +63,8 @@ module Datadog
 
         def on_test_step_finished(event)
           return if @current_step_span.nil?
-          unless event.result.passed?
-            @current_step_span.set_error event.result.exception
-          end
+
+          @current_step_span.set_error event.result.exception unless event.result.passed?
           @current_step_span.set_tag(Datadog::Ext::Test::TAG_STATUS, status_from_result(event.result))
           @current_step_span.finish
         end
@@ -84,6 +77,7 @@ module Datadog
           elsif result.ok?
             return Datadog::Ext::Test::Status::PASS
           end
+
           Datadog::Ext::Test::Status::FAIL
         end
 

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

@@ -27,6 +27,11 @@ module Datadog
           super && version >= MINIMUM_VERSION
         end
 
+        # test environments should not auto instrument test libraries
+        def auto_instrument?
+          false
+        end
+
         def default_configuration
           Configuration::Settings.new
         end

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

@@ -17,46 +17,8 @@ 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
-        end
       end
     end
   end

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

@@ -12,7 +12,6 @@ module Datadog
 
           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

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

@@ -1,3 +1,4 @@
+require 'ddtrace/patcher'
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/integration'

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

@@ -13,8 +13,8 @@ module Datadog
         def self.included(base)
           base.send(:prepend, InstanceMethods)
         end
+
         # InstanceMethods - implementing instrumentation
-        # rubocop:disable Metrics/ModuleLength
         module InstanceMethods
           include Datadog::Contrib::HttpAnnotationHelper
 
@@ -36,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
@@ -99,21 +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)
@@ -124,7 +126,6 @@ module Datadog
 
           def uri
             URI.parse(url)
-          # rubocop:disable Lint/HandleExceptions
           rescue URI::InvalidURIError
           end
 

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

@@ -12,6 +12,7 @@ module Datadog
         SERVICE_NAME = 'ethon'.freeze
         SPAN_REQUEST = 'ethon.request'.freeze
         SPAN_MULTI_REQUEST = 'ethon.multi.request'.freeze
+        NOT_APPLICABLE_METHOD = 'N/A'.freeze
       end
     end
   end

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

@@ -119,9 +119,7 @@ module Datadog
           span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
 
           # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-          end
+          Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
           span.set_tag(Datadog::Ext::HTTP::URL, datum[:path])
           span.set_tag(Datadog::Ext::HTTP::METHOD, datum[:method].to_s.upcase)
@@ -136,9 +134,7 @@ module Datadog
 
               if datum.key?(:response)
                 response = datum[:response]
-                if error_handler.call(response)
-                  span.set_error(["Error #{response[:status]}", response[:body]])
-                end
+                span.set_error(["Error #{response[:status]}", response[:body]]) if error_handler.call(response)
                 span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response[:status])
               end
               span.set_error(datum[:error]) if datum.key?(:error)