ddtrace 0.34.1 → 1.23.1

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

@@ -1,157 +0,0 @@
-require 'excon'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/excon/ext'
-require 'ddtrace/contrib/http_annotation_helper'
-
-module Datadog
-  module Contrib
-    module Excon
-      # Middleware implements an excon-middleware for ddtrace instrumentation
-      class Middleware < ::Excon::Middleware::Base
-        include Datadog::Contrib::HttpAnnotationHelper
-
-        DEFAULT_ERROR_HANDLER = lambda do |response|
-          Datadog::Ext::HTTP::ERROR_RANGE.cover?(response[:status])
-        end
-
-        def initialize(stack, options = {})
-          super(stack)
-          @default_options = datadog_configuration.options_hash.merge(options)
-        end
-
-        def request_call(datum)
-          begin
-            unless datum.key?(:datadog_span)
-              @options = build_request_options!(datum)
-              tracer.trace(Ext::SPAN_REQUEST).tap do |span|
-                datum[:datadog_span] = span
-                annotate!(span, datum)
-                propagate!(span, datum) if distributed_tracing?
-              end
-            end
-          rescue StandardError => e
-            Datadog::Logger.log.debug(e.message)
-          end
-
-          @stack.request_call(datum)
-        end
-
-        def response_call(datum)
-          @stack.response_call(datum).tap do |d|
-            handle_response(d)
-          end
-        end
-
-        def error_call(datum)
-          handle_response(datum)
-          @stack.error_call(datum)
-        end
-
-        # Returns a child class of this trace middleware
-        # With options given as defaults.
-        def self.with(options = {})
-          Class.new(self) do
-            @options = options
-
-            # rubocop:disable Style/TrivialAccessors
-            def self.options
-              @options
-            end
-
-            def initialize(stack)
-              super(stack, self.class.options)
-            end
-          end
-        end
-
-        # Returns a copy of the default stack with the trace middleware injected
-        def self.around_default_stack
-          ::Excon.defaults[:middlewares].dup.tap do |default_stack|
-            # If the default stack contains a version of the trace middleware already...
-            existing_trace_middleware = default_stack.find { |m| m <= Middleware }
-            default_stack.delete(existing_trace_middleware) if existing_trace_middleware
-
-            # Inject after the ResponseParser middleware
-            response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
-            default_stack.insert(response_middleware_index + 1, self)
-          end
-        end
-
-        private
-
-        def tracer
-          @options[:tracer]
-        end
-
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(@options[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          @options[:analytics_sample_rate]
-        end
-
-        def distributed_tracing?
-          @options[:distributed_tracing] == true && tracer.enabled
-        end
-
-        def error_handler
-          @options[:error_handler] || DEFAULT_ERROR_HANDLER
-        end
-
-        def annotate!(span, datum)
-          span.resource = datum[:method].to_s.upcase
-          span.service = service_name(datum[:host], @options)
-          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
-
-          # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-          end
-
-          span.set_tag(Datadog::Ext::HTTP::URL, datum[:path])
-          span.set_tag(Datadog::Ext::HTTP::METHOD, datum[:method].to_s.upcase)
-          span.set_tag(Datadog::Ext::NET::TARGET_HOST, datum[:host])
-          span.set_tag(Datadog::Ext::NET::TARGET_PORT, datum[:port])
-        end
-
-        def handle_response(datum)
-          if datum.key?(:datadog_span)
-            datum[:datadog_span].tap do |span|
-              return span if span.finished?
-
-              if datum.key?(:response)
-                response = datum[:response]
-                if error_handler.call(response)
-                  span.set_error(["Error #{response[:status]}", response[:body]])
-                end
-                span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response[:status])
-              end
-              span.set_error(datum[:error]) if datum.key?(:error)
-              span.finish
-              datum.delete(:datadog_span)
-            end
-          end
-        rescue StandardError => e
-          Datadog::Logger.log.debug(e.message)
-        end
-
-        def propagate!(span, datum)
-          Datadog::HTTPPropagator.inject!(span.context, datum[:headers])
-        end
-
-        def build_request_options!(datum)
-          datadog_configuration(datum[:host]).options_hash.merge(@default_options)
-        end
-
-        def datadog_configuration(host = :default)
-          Datadog.configuration[:excon, host]
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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::Configuration::Settings.send(:include, Configuration::Settings)
-      end
-
-      # Helper methods for Datadog module.
-      module Helpers
-        def registry
-          configuration.registry
-        end
-      end
-
-      module Configuration
-        # 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 use(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)
-            end
-
-            integration.patch if integration.respond_to?(:patch)
-          end
-
-          private
-
-          def fetch_integration(name)
-            get_option(:registry)[name] ||
-              raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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,81 +0,0 @@
-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 = datadog_configuration.options_hash.merge(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, :options
-
-        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(env[:url].host).options_hash.merge(options)
-        end
-
-        def datadog_configuration(host = :default)
-          Datadog.configuration[:faraday, host]
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-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
-        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 tracer=(tracer)
-            Datadog.configuration[:faraday][:tracer] = tracer
-          end
-
-          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.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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