ddtrace 0.45.0 → 0.47.0

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

@@ -5,33 +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)
-            return if patterns.empty?
+        # 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
+            config
           end
 
-          def add(pattern)
-            patterns << (pattern.is_a?(Regexp) || pattern.is_a?(Proc) ? pattern : pattern.to_s)
-          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/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
@@ -100,9 +102,7 @@ module Datadog
           def datadog_tag_request
             span = @datadog_span
             method = Ext::NOT_APPLICABLE_METHOD
-            if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-              method = @datadog_method.to_s
-            end
+            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)
@@ -111,6 +111,7 @@ module Datadog
 
             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)
@@ -125,7 +126,6 @@ module Datadog
 
           def uri
             URI.parse(url)
-          # rubocop:disable Lint/HandleExceptions
           rescue URI::InvalidURIError
           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)

data/lib/ddtrace/contrib/extensions.rb

@@ -30,6 +30,7 @@ module Datadog
             reduce_verbosity = target.respond_to?(:reduce_verbosity?) ? target.reduce_verbosity? : false
             target.integrations_pending_activation.each do |integration|
               next unless integration.respond_to?(:patch)
+
               # integration.patch returns either true or a hash of details on why patching failed
               patch_results = integration.patch
 
@@ -46,7 +47,7 @@ module Datadog
               desc += ", Compatible? #{patch_results[:compatible]}"
               desc += ", Patchable? #{patch_results[:patchable]}"
 
-              Datadog.logger.warn("Unable to patch #{patch_results['name']} (#{desc})")
+              Datadog.logger.warn("Unable to patch #{patch_results[:name]} (#{desc})")
             end
 
             target.integrations_pending_activation.clear
@@ -66,9 +67,32 @@ module Datadog
             end
           end
 
-          def [](integration_name, configuration_name = :default)
+          # For the provided `integration_name`, resolves a matching configuration
+          # for the provided integration from an integration-specific `key`.
+          #
+          # How the matching is performed is integration-specific.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] key the integration-specific lookup key
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def [](integration_name, key = :default)
+            integration = fetch_integration(integration_name)
+            integration.resolve(key) unless integration.nil?
+          end
+
+          # For the provided `integration_name`, retrieves a configuration previously
+          # stored by `#instrument`. Specifically, `describes` should be
+          # the same value provided in the `describes:` option for `#instrument`.
+          #
+          # If no `describes` value is provided, the default configuration is returned.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] describes the previously configured `describes:` object. If `nil`,
+          #   fetches the default configuration
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def configuration(integration_name, describes = nil)
             integration = fetch_integration(integration_name)
-            integration.configuration(configuration_name) unless integration.nil?
+            integration.configuration(describes) unless integration.nil?
           end
 
           def instrument(integration_name, options = {}, &block)

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

@@ -57,9 +57,7 @@ module Datadog
         end
 
         def handle_response(span, env, options)
-          if options.fetch(:error_handler).call(env)
-            span.set_error(["Error #{env[:status]}", env[:body]])
-          end
+          span.set_error(["Error #{env[:status]}", env[:body]]) if options.fetch(:error_handler).call(env)
 
           span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, env[:status])
         end

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

@@ -20,21 +20,10 @@ module Datadog
         def patch
           require 'ddtrace/contrib/faraday/middleware'
 
-          add_pin!
           register_middleware!
           add_default_middleware!
         end
 
-        def add_pin!
-          DeprecatedPin
-            .new(
-              get_option(:service_name),
-              app: Ext::APP,
-              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-              tracer: -> { get_option(:tracer) }
-            ).onto(::Faraday)
-        end
-
         def register_middleware!
           ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
         end
@@ -58,31 +47,6 @@ module Datadog
             ::Faraday::RackBuilder.send(:prepend, RackBuilder)
           end
         end
-
-        def get_option(option)
-          Datadog.configuration[:faraday].get_option(option)
-        end
-
-        # Implementation of deprecated Pin, which raises warnings when accessed.
-        # To be removed when support for Datadog::Pin with Faraday is removed.
-        class DeprecatedPin < Datadog::Pin
-          include Datadog::DeprecatedPin
-
-          DEPRECATION_WARNING = %(
-            Use of Datadog::Pin with Faraday 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[:faraday][: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