ddtrace 0.38.0

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module Excon
+      # Patcher enables patching of 'excon' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require 'ddtrace/contrib/excon/middleware'
+          add_middleware
+        end
+
+        def add_middleware
+          ::Excon.defaults[:middlewares] = Middleware.around_default_stack
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/extensions.rb

@@ -0,0 +1,93 @@
+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)
+            target.integrations_pending_activation.each do |integration|
+              integration.patch if integration.respond_to?(:patch)
+            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
+
+          def [](integration_name, configuration_name = :default)
+            integration = fetch_integration(integration_name)
+            integration.configuration(configuration_name) unless integration.nil?
+          end
+
+          def instrument(integration_name, options = {}, &block)
+            integration = fetch_integration(integration_name)
+
+            unless integration.nil?
+              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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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 :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            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 :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,14 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Faraday integration constants
+      module Ext
+        APP = 'faraday'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_FARADAY_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = '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

@@ -0,0 +1,83 @@
+require 'faraday'
+require 'ddtrace/ext/http'
+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 Datadog::Ext::DistributedTracing
+        include Datadog::Contrib::HttpAnnotationHelper
+
+        def initialize(app, options = {})
+          super(app)
+          @options = options
+        end
+
+        def call(env)
+          # 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
+
+        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
+
+          # 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(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)
+          if options.fetch(:error_handler).call(env)
+            span.set_error(["Error #{env[:status]}", env[:body]])
+          end
+
+          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 resource_name(env)
+          env[:method].to_s.upcase
+        end
+
+        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
+
+        def datadog_configuration(host = :default)
+          Datadog.configuration[:faraday, host]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+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
+      # Patcher enables patching of 'faraday' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        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::AppTypes::WEB,
+              tracer: -> { get_option(:tracer) }
+            ).onto(::Faraday)
+        end
+
+        def register_middleware!
+          ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
+        end
+
+        def add_default_middleware!
+          if target_version >= Gem::Version.new('1.0.0')
+            ::Faraday::Connection.send(:prepend, Connection)
+          else
+            ::Faraday::RackBuilder.send(:prepend, RackBuilder)
+          end
+
+          # Instrument the Faraday default connection (e.g. +Faraday.get+)
+          ::Faraday.default_connection.use(:ddtrace)
+        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
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Faraday
+      # Handles installation of our middleware if the user has *not*
+      # already explicitly configured it for this correction.
+      #
+      # RackBuilder class was introduced in faraday 0.9.0:
+      # https://github.com/lostisland/faraday/commit/77d7546d6d626b91086f427c56bc2cdd951353b3
+      module RackBuilder
+        def adapter(*args)
+          use(:ddtrace) unless @handlers.any? { |h| h.klass == Middleware }
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/grape/ext'
+
+module Datadog
+  module Contrib
+    module Grape
+      module Configuration
+        # Custom settings for the Grape integration
+        class Settings < Contrib::Configuration::Settings
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+            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 :enabled, default: true
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end