ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/contrib/extensions.rb

@@ -0,0 +1,143 @@
+require 'set'
+require 'ddtrace/contrib/registry'
+
+module Datadog
+  module Contrib
+    # Extensions that can be added to the base library
+    # Adds registry, configuration access for integrations.
+    module Extensions
+      def self.extended(base)
+        Datadog.send(:extend, Helpers)
+        Datadog.send(:extend, Configuration)
+        Datadog::Configuration::Settings.send(:include, Configuration::Settings)
+      end
+
+      # Helper methods for Datadog module.
+      module Helpers
+        def registry
+          configuration.registry
+        end
+      end
+
+      # Configuration methods for Datadog module.
+      module Configuration
+        def configure(target = configuration, opts = {})
+          # Reconfigure core settings
+          super
+
+          # Activate integrations
+          if target.respond_to?(:integrations_pending_activation)
+            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
+
+              next if patch_results == true
+
+              # if patching failed, only log output if verbosity is unset
+              # or if patching failure is due to compatibility or integration specific reasons
+              next unless !reduce_verbosity ||
+                          ((patch_results[:available] && patch_results[:loaded]) &&
+                           (!patch_results[:compatible] || !patch_results[:patchable]))
+
+              desc = "Available?: #{patch_results[:available]}"
+              desc += ", Loaded? #{patch_results[:loaded]}"
+              desc += ", Compatible? #{patch_results[:compatible]}"
+              desc += ", Patchable? #{patch_results[:patchable]}"
+
+              Datadog.logger.warn("Unable to patch #{patch_results[:name]} (#{desc})")
+            end
+
+            target.integrations_pending_activation.clear
+          end
+
+          target
+        end
+
+        # Extensions for Datadog::Configuration::Settings
+        module Settings
+          InvalidIntegrationError = Class.new(StandardError)
+
+          def self.included(base)
+            # Add the additional options to the global configuration settings
+            base.instance_eval do
+              option :registry, default: Registry.new
+            end
+          end
+
+          # 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(describes) unless integration.nil?
+          end
+
+          def instrument(integration_name, options = {}, &block)
+            integration = fetch_integration(integration_name)
+
+            unless integration.nil? || !integration.default_configuration.enabled
+              configuration_name = options[:describes] || :default
+              filtered_options = options.reject { |k, _v| k == :describes }
+              integration.configure(configuration_name, filtered_options, &block)
+              instrumented_integrations[integration_name] = integration
+
+              # Add to activation list
+              integrations_pending_activation << integration
+            end
+          end
+
+          alias_method :use, :instrument
+
+          def integrations_pending_activation
+            @integrations_pending_activation ||= Set.new
+          end
+
+          def instrumented_integrations
+            @instrumented_integrations ||= {}
+          end
+
+          def reset!
+            instrumented_integrations.clear
+            super
+          end
+
+          def fetch_integration(name)
+            registry[name] ||
+              raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
+          end
+
+          def reduce_verbosity?
+            defined?(@reduce_verbosity) ? @reduce_verbosity : false
+          end
+
+          def reduce_log_verbosity
+            @reduce_verbosity ||= true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/faraday/ext'
+
+module Datadog
+  module Contrib
+    module Faraday
+      module Configuration
+        # Custom settings for the Faraday integration
+        class Settings < Contrib::Configuration::Settings
+          DEFAULT_ERROR_HANDLER = lambda do |env|
+            Datadog::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
+          end
+
+          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 :error_handler, default: DEFAULT_ERROR_HANDLER
+          option :service_name, default: Ext::SERVICE_NAME
+          option :split_by_domain, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Handles installation of our middleware if the user has *not*
+      # already explicitly configured our middleware for this correction.
+      #
+      # Wraps Faraday::Connection#initialize:
+      # https://github.com/lostisland/faraday/blob/ff9dc1d1219a1bbdba95a9a4cf5d135b97247ee2/lib/faraday/connection.rb#L62-L92
+      module Connection
+        def initialize(*args, &block)
+          super.tap do
+            use(:ddtrace) unless builder.handlers.any? { |h| h.klass == Middleware }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Faraday integration constants
+      module Ext
+        APP = 'faraday'.freeze
+        ENV_ENABLED = 'DD_TRACE_FARADAY_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_FARADAY_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_FARADAY_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'faraday'.freeze
+        SPAN_REQUEST = 'faraday.request'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
+require 'ddtrace/contrib/faraday/configuration/settings'
+require 'ddtrace/contrib/faraday/patcher'
+
+module Datadog
+  module Contrib
+    module Faraday
+      # Description of Faraday integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('0.14.0')
+
+        register_as :faraday, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['faraday'] && Gem.loaded_specs['faraday'].version
+        end
+
+        def self.loaded?
+          !defined?(::Faraday).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
+      end
+    end
+  end
+end

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

@@ -1,66 +1,83 @@
 require 'faraday'
 require 'ddtrace/ext/http'
+require 'ddtrace/ext/integration'
 require 'ddtrace/ext/net'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/http_annotation_helper'
 
 module Datadog
   module Contrib
     module Faraday
       # Middleware implements a faraday-middleware for ddtrace instrumentation
       class Middleware < ::Faraday::Middleware
-        include Ext::DistributedTracing
+        include Datadog::Ext::DistributedTracing
+        include Datadog::Contrib::HttpAnnotationHelper
 
         def initialize(app, options = {})
           super(app)
-          @options = Datadog.configuration[:faraday].merge(options)
-          @tracer = Pin.get_from(::Faraday).tracer
-          setup_service!
+          @options = options
         end
 
         def call(env)
-          tracer.trace(NAME) do |span|
-            annotate!(span, env)
-            propagate!(span, env) if options[:distributed_tracing] && tracer.enabled
-            app.call(env).on_complete { |resp| handle_response(span, resp) }
+          # Resolve configuration settings to use for this request.
+          # Do this once to reduce expensive regex calls.
+          request_options = build_request_options!(env)
+
+          request_options[:tracer].trace(Ext::SPAN_REQUEST) do |span|
+            annotate!(span, env, request_options)
+            propagate!(span, env) if request_options[:distributed_tracing] && request_options[:tracer].enabled
+            app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
           end
         end
 
         private
 
-        attr_reader :app, :options, :tracer
+        attr_reader :app
 
-        def annotate!(span, env)
-          span.resource = env[:method].to_s.upcase
-          span.service = service_name(env)
-          span.span_type = Ext::HTTP::TYPE
-          span.set_tag(Ext::HTTP::URL, env[:url].path)
-          span.set_tag(Ext::HTTP::METHOD, env[:method].to_s.upcase)
-          span.set_tag(Ext::NET::TARGET_HOST, env[:url].host)
-          span.set_tag(Ext::NET::TARGET_PORT, env[:url].port)
-        end
+        def annotate!(span, env, options)
+          span.resource = resource_name(env)
+          service_name(env[:url].host, options)
+          span.service = options[:split_by_domain] ? env[:url].host : options[:service_name]
+          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
 
-        def handle_response(span, env)
-          if options.fetch(:error_handler).call(env)
-            span.set_error(["Error #{env[:status]}", env[:body]])
+          # 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?(options[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
           end
 
-          span.set_tag(Ext::HTTP::STATUS_CODE, env[:status])
+          span.set_tag(Datadog::Ext::HTTP::URL, env[:url].path)
+          span.set_tag(Datadog::Ext::HTTP::METHOD, env[:method].to_s.upcase)
+          span.set_tag(Datadog::Ext::NET::TARGET_HOST, env[:url].host)
+          span.set_tag(Datadog::Ext::NET::TARGET_PORT, env[:url].port)
+        end
+
+        def handle_response(span, env, options)
+          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
 
         def propagate!(span, env)
           Datadog::HTTPPropagator.inject!(span.context, env[:request_headers])
         end
 
-        def service_name(env)
-          return env[:url].host if options[:split_by_domain]
-
-          options[:service_name]
+        def resource_name(env)
+          env[:method].to_s.upcase
         end
 
-        def setup_service!
-          return if options[:service_name] == Datadog.configuration[:faraday][:service_name]
+        def build_request_options!(env)
+          datadog_configuration.options_hash # integration level settings
+                               .merge(datadog_configuration(env[:url].host).options_hash) # per-host override
+                               .merge(@options) # middleware instance override
+        end
 
-          Patcher.register_service(options[:service_name])
+        def datadog_configuration(host = :default)
+          Datadog.configuration[:faraday, host]
         end
       end
     end

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

@@ -1,70 +1,50 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/faraday/connection'
+require 'ddtrace/contrib/faraday/rack_builder'
+
 module Datadog
   module Contrib
     module Faraday
-      COMPATIBLE_UNTIL = Gem::Version.new('1.0.0')
-      SERVICE = 'faraday'.freeze
-      NAME = 'faraday.request'.freeze
-
-      # Responsible for hooking the instrumentation into faraday
+      # Patcher enables patching of 'faraday' module.
       module Patcher
-        include Base
+        include Contrib::Patcher
 
-        register_as :faraday, auto_patch: true
+        module_function
 
-        DEFAULT_ERROR_HANDLER = lambda do |env|
-          Ext::HTTP::ERROR_RANGE.cover?(env[:status])
+        def target_version
+          Integration.version
         end
 
-        option :service_name, default: SERVICE
-        option :distributed_tracing, default: false
-        option :error_handler, default: DEFAULT_ERROR_HANDLER
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
-
-        class << self
-          def patch
-            return @patched if patched? || !compatible?
-
-            require 'ddtrace/ext/app_types'
-            require 'ddtrace/contrib/faraday/middleware'
-
-            add_pin
-            add_middleware
-
-            @patched = true
-          rescue => e
-            Tracer.log.error("Unable to apply Faraday integration: #{e}")
-            @patched
-          end
-
-          def patched?
-            @patched
-          end
-
-          def register_service(name)
-            get_option(:tracer).set_service_info(name, 'faraday', Ext::AppTypes::WEB)
-          end
-
-          private
-
-          def compatible?
-            return unless defined?(::Faraday::VERSION)
+        def patch
+          require 'ddtrace/contrib/faraday/middleware'
 
-            Gem::Version.new(::Faraday::VERSION) < COMPATIBLE_UNTIL
-          end
+          register_middleware!
+          add_default_middleware!
+        end
 
-          def add_pin
-            Pin.new(
-              get_option(:service_name),
-              app: 'faraday',
-              app_type: Ext::AppTypes::WEB,
-              tracer: get_option(:tracer)
-            ).onto(::Faraday)
-          end
+        def register_middleware!
+          ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
+        end
 
-          def add_middleware
-            ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
+        def add_default_middleware!
+          if target_version >= Gem::Version.new('1.0.0')
+            # Patch the default connection (e.g. +Faraday.get+)
+            ::Faraday.default_connection.use(:ddtrace)
+
+            # Patch new connection instances (e.g. +Faraday.new+)
+            ::Faraday::Connection.send(:prepend, Connection)
+          else
+            # Patch the default connection (e.g. +Faraday.get+)
+            #
+            # We insert our middleware before the 'adapter', which is
+            # always the last handler.
+            idx = ::Faraday.default_connection.builder.handlers.size - 1
+            ::Faraday.default_connection.builder.insert(idx, Middleware)
+
+            # Patch new connection instances (e.g. +Faraday.new+)
+            ::Faraday::RackBuilder.send(:prepend, RackBuilder)
           end
         end
       end