httpx 0.21.0 → 1.2.1

data/lib/httpx/adapters/datadog.rb

@@ -1,51 +1,24 @@
 # frozen_string_literal: true
 
-if defined?(::DDTrace) && ::DDTrace::VERSION::STRING >= "1.0.0"
-  require "datadog/tracing/contrib/integration"
-  require "datadog/tracing/contrib/configuration/settings"
-  require "datadog/tracing/contrib/patcher"
+require "datadog/tracing/contrib/integration"
+require "datadog/tracing/contrib/configuration/settings"
+require "datadog/tracing/contrib/patcher"
 
-  TRACING_MODULE = Datadog::Tracing
-else
-
-  require "ddtrace/contrib/integration"
-  require "ddtrace/contrib/configuration/settings"
-  require "ddtrace/contrib/patcher"
-
-  TRACING_MODULE = Datadog
-end
-
-module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
+module Datadog::Tracing
   module Contrib
     module HTTPX
-      if defined?(::DDTrace) && ::DDTrace::VERSION::STRING >= "1.0.0"
-        METADATA_MODULE = TRACING_MODULE::Metadata
-
-        TYPE_OUTBOUND = TRACING_MODULE::Metadata::Ext::HTTP::TYPE_OUTBOUND
-
-        TAG_PEER_SERVICE = TRACING_MODULE::Metadata::Ext::TAG_PEER_SERVICE
+      METADATA_MODULE = Datadog::Tracing::Metadata
 
-        TAG_URL = TRACING_MODULE::Metadata::Ext::HTTP::TAG_URL
-        TAG_METHOD = TRACING_MODULE::Metadata::Ext::HTTP::TAG_METHOD
-        TAG_TARGET_HOST = TRACING_MODULE::Metadata::Ext::NET::TAG_TARGET_HOST
-        TAG_TARGET_PORT = TRACING_MODULE::Metadata::Ext::NET::TAG_TARGET_PORT
+      TYPE_OUTBOUND = Datadog::Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
-        TAG_STATUS_CODE = TRACING_MODULE::Metadata::Ext::HTTP::TAG_STATUS_CODE
+      TAG_PEER_SERVICE = Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
 
-      else
+      TAG_URL = Datadog::Tracing::Metadata::Ext::HTTP::TAG_URL
+      TAG_METHOD = Datadog::Tracing::Metadata::Ext::HTTP::TAG_METHOD
+      TAG_TARGET_HOST = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_HOST
+      TAG_TARGET_PORT = Datadog::Tracing::Metadata::Ext::NET::TAG_TARGET_PORT
 
-        METADATA_MODULE = Datadog
-
-        TYPE_OUTBOUND = TRACING_MODULE::Ext::HTTP::TYPE_OUTBOUND
-        TAG_PEER_SERVICE = TRACING_MODULE::Ext::Integration::TAG_PEER_SERVICE
-        TAG_URL = TRACING_MODULE::Ext::HTTP::URL
-        TAG_METHOD = TRACING_MODULE::Ext::HTTP::METHOD
-        TAG_TARGET_HOST = TRACING_MODULE::Ext::NET::TARGET_HOST
-        TAG_TARGET_PORT = TRACING_MODULE::Ext::NET::TARGET_PORT
-        TAG_STATUS_CODE = Datadog::Ext::HTTP::STATUS_CODE
-        PROPAGATOR = TRACING_MODULE::HTTPPropagator
-
-      end
+      TAG_STATUS_CODE = Datadog::Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE
 
       # HTTPX Datadog Plugin
       #
@@ -64,14 +37,18 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
           end
 
           def call
-            return unless tracing_enabled?
+            return unless Datadog::Tracing.enabled?
 
             @request.on(:response, &method(:finish))
 
-            verb = @request.verb.to_s.upcase
+            verb = @request.verb
             uri = @request.uri
 
-            @span = build_span
+            @span = Datadog::Tracing.trace(
+              SPAN_REQUEST,
+              service: service_name(@request.uri.host, configuration, Datadog.configuration_for(self)),
+              span_type: TYPE_OUTBOUND
+            )
 
             @span.resource = verb
 
@@ -86,7 +63,8 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
             # Tag as an external peer service
             @span.set_tag(TAG_PEER_SERVICE, @span.service)
 
-            propagate_headers if @configuration[:distributed_tracing]
+            Datadog::Tracing::Propagation::HTTP.inject!(Datadog::Tracing.active_trace,
+                                                        @request.headers) if @configuration[:distributed_tracing]
 
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(@configuration[:analytics_enabled])
@@ -113,54 +91,24 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
 
           private
 
-          if defined?(::DDTrace) && ::DDTrace::VERSION::STRING >= "1.0.0"
-
-            def build_span
-              TRACING_MODULE.trace(
-                SPAN_REQUEST,
-                service: service_name(@request.uri.host, configuration, Datadog.configuration_for(self)),
-                span_type: TYPE_OUTBOUND
-              )
-            end
-
-            def propagate_headers
-              TRACING_MODULE::Propagation::HTTP.inject!(TRACING_MODULE.active_trace, @request.headers)
-            end
-
-            def configuration
-              @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
-            end
-
-            def tracing_enabled?
-              TRACING_MODULE.enabled?
-            end
-          else
-            def build_span
-              service_name = configuration[:split_by_domain] ? @request.uri.host : configuration[:service_name]
-              configuration[:tracer].trace(
-                SPAN_REQUEST,
-                service: service_name,
-                span_type: TYPE_OUTBOUND
-              )
-            end
-
-            def propagate_headers
-              Datadog::HTTPPropagator.inject!(@span.context, @request.headers)
-            end
+          def configuration
+            @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
+          end
+        end
 
-            def configuration
-              @configuration ||= Datadog.configuration[:httpx, @request.uri.host]
-            end
+        module RequestMethods
+          def __datadog_enable_trace!
+            return if @__datadog_enable_trace
 
-            def tracing_enabled?
-              configuration[:tracer].enabled
-            end
+            RequestTracer.new(self).call
+            @__datadog_enable_trace = true
           end
         end
 
         module ConnectionMethods
           def send(request)
-            RequestTracer.new(request).call
+            request.__datadog_enable_trace!
+
             super
           end
         end
@@ -169,7 +117,7 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
       module Configuration
         # Default settings for httpx
         #
-        class Settings < TRACING_MODULE::Contrib::Configuration::Settings
+        class Settings < Datadog::Tracing::Contrib::Configuration::Settings
           DEFAULT_ERROR_HANDLER = lambda do |response|
             Datadog::Ext::HTTP::ERROR_RANGE.cover?(response.status)
           end
@@ -178,29 +126,82 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
           option :distributed_tracing, default: true
           option :split_by_domain, default: false
 
-          option :enabled do |o|
-            o.default { env_to_bool("DD_TRACE_HTTPX_ENABLED", true) }
-            o.lazy
-          end
+          if Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ENABLED"
+              o.default true
+            end
+
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env "DD_TRACE_HTTPX_ANALYTICS_ENABLED"
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env "DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE"
+              o.default 1.0
+            end
+          else
+            option :enabled do |o|
+              o.default { env_to_bool("DD_TRACE_HTTPX_ENABLED", true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(%w[DD_TRACE_HTTPX_ANALYTICS_ENABLED DD_HTTPX_ANALYTICS_ENABLED], false) }
+              o.lazy
+            end
 
-          option :analytics_enabled do |o|
-            o.default { env_to_bool(%w[DD_TRACE_HTTPX_ANALYTICS_ENABLED DD_HTTPX_ANALYTICS_ENABLED], false) }
-            o.lazy
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(%w[DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE DD_HTTPX_ANALYTICS_SAMPLE_RATE], 1.0) }
+              o.lazy
+            end
           end
 
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float(%w[DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE DD_HTTPX_ANALYTICS_SAMPLE_RATE], 1.0) }
-            o.lazy
+          if defined?(Datadog::Tracing::Contrib::SpanAttributeSchema)
+            option :service_name do |o|
+              o.default do
+                Datadog::Tracing::Contrib::SpanAttributeSchema.fetch_service_name(
+                  "DD_TRACE_HTTPX_SERVICE_NAME",
+                  "httpx"
+                )
+              end
+              o.lazy
+            end
+          else
+            option :service_name do |o|
+              o.default do
+                ENV.fetch("DD_TRACE_HTTPX_SERVICE_NAME", "httpx")
+              end
+              o.lazy
+            end
           end
 
-          option :error_handler, default: DEFAULT_ERROR_HANDLER
+          option :distributed_tracing, default: true
+
+          if Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.15.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          elsif Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+            option :error_handler do |o|
+              o.type :proc
+              o.experimental_default_proc(&DEFAULT_ERROR_HANDLER)
+            end
+          else
+            option :error_handler, default: DEFAULT_ERROR_HANDLER
+          end
         end
       end
 
       # Patcher enables patching of 'httpx' with datadog components.
       #
       module Patcher
-        include TRACING_MODULE::Contrib::Patcher
+        include Datadog::Tracing::Contrib::Patcher
 
         module_function
 
@@ -223,7 +224,6 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
       class Integration
         include Contrib::Integration
 
-        # MINIMUM_VERSION = Gem::Version.new('0.11.0')
         MINIMUM_VERSION = Gem::Version.new("0.10.2")
 
         register_as :httpx
@@ -240,14 +240,8 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
           super && version >= MINIMUM_VERSION
         end
 
-        if defined?(::DDTrace) && ::DDTrace::VERSION::STRING >= "1.0.0"
-          def new_configuration
-            Configuration::Settings.new
-          end
-        else
-          def default_configuration
-            Configuration::Settings.new
-          end
+        def new_configuration
+          Configuration::Settings.new
         end
 
         def patcher

data/lib/httpx/adapters/faraday.rb

@@ -7,36 +7,54 @@ require "faraday"
 module Faraday
   class Adapter
     class HTTPX < Faraday::Adapter
-      # :nocov:
-      SSL_ERROR = if defined?(Faraday::SSLError)
-        Faraday::SSLError
-      else
-        Faraday::Error::SSLError
-      end
+      module RequestMixin
+        def build_connection(env)
+          return @connection if defined?(@connection)
 
-      CONNECTION_FAILED_ERROR = if defined?(Faraday::ConnectionFailed)
-        Faraday::ConnectionFailed
-      else
-        Faraday::Error::ConnectionFailed
-      end
-      # :nocov:
+          @connection = ::HTTPX.plugin(:persistent).plugin(ReasonPlugin)
+          @connection = @connection.with(@connection_options) unless @connection_options.empty?
+          connection_opts = options_from_env(env)
 
-      unless Faraday::RequestOptions.method_defined?(:stream_response?)
-        module RequestOptionsExtensions
-          refine Faraday::RequestOptions do
-            def stream_response?
-              false
-            end
+          if (bind = env.request.bind)
+            @bind = TCPSocket.new(bind[:host], bind[:port])
+            connection_opts[:io] = @bind
+          end
+          @connection = @connection.with(connection_opts)
+
+          if (proxy = env.request.proxy)
+            proxy_options = { uri: proxy.uri }
+            proxy_options[:username] = proxy.user if proxy.user
+            proxy_options[:password] = proxy.password if proxy.password
+
+            @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
           end
+          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+
+          @connection
         end
-        using RequestOptionsExtensions
-      end
 
-      module RequestMixin
-        using ::HTTPX::HashExtensions
+        def close
+          @connection.close if @connection
+          @bind.close if @bind
+        end
 
         private
 
+        def connect(env, &blk)
+          connection(env, &blk)
+        rescue ::HTTPX::TLSError => e
+          raise Faraday::SSLError, e
+        rescue Errno::ECONNABORTED,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET,
+               Errno::EHOSTUNREACH,
+               Errno::EINVAL,
+               Errno::ENETUNREACH,
+               Errno::EPIPE,
+               ::HTTPX::ConnectionError => e
+          raise Faraday::ConnectionFailed, e
+        end
+
         def build_request(env)
           meth = env[:method]
 
@@ -44,32 +62,53 @@ module Faraday
             headers: env.request_headers,
             body: env.body,
           }
-          [meth, env.url, request_options]
+          [meth.to_s.upcase, env.url, request_options]
         end
 
         def options_from_env(env)
-          timeout_options = {
-            connect_timeout: env.request.open_timeout,
-            operation_timeout: env.request.timeout,
-          }.compact
+          timeout_options = {}
+          req_opts = env.request
+          if (sec = request_timeout(:read, req_opts))
+            timeout_options[:read_timeout] = sec
+          end
 
-          options = {
-            ssl: {},
+          if (sec = request_timeout(:write, req_opts))
+            timeout_options[:write_timeout] = sec
+          end
+
+          if (sec = request_timeout(:open, req_opts))
+            timeout_options[:connect_timeout] = sec
+          end
+
+          {
+            ssl: ssl_options_from_env(env),
             timeout: timeout_options,
           }
+        end
+
+        if defined?(::OpenSSL)
+          def ssl_options_from_env(env)
+            ssl_options = {}
+
+            unless env.ssl.verify.nil?
+              ssl_options[:verify_mode] = env.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+            end
 
-          options[:ssl][:verify_mode] = OpenSSL::SSL::VERIFY_PEER if env.ssl.verify
-          options[:ssl][:ca_file] = env.ssl.ca_file if env.ssl.ca_file
-          options[:ssl][:ca_path] = env.ssl.ca_path if env.ssl.ca_path
-          options[:ssl][:cert_store] = env.ssl.cert_store if env.ssl.cert_store
-          options[:ssl][:cert] = env.ssl.client_cert if env.ssl.client_cert
-          options[:ssl][:key] = env.ssl.client_key if env.ssl.client_key
-          options[:ssl][:ssl_version] = env.ssl.version if env.ssl.version
-          options[:ssl][:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
-          options[:ssl][:min_version] = env.ssl.min_version if env.ssl.min_version
-          options[:ssl][:max_version] = env.ssl.max_version if env.ssl.max_version
-
-          options
+            ssl_options[:ca_file] = env.ssl.ca_file if env.ssl.ca_file
+            ssl_options[:ca_path] = env.ssl.ca_path if env.ssl.ca_path
+            ssl_options[:cert_store] = env.ssl.cert_store if env.ssl.cert_store
+            ssl_options[:cert] = env.ssl.client_cert if env.ssl.client_cert
+            ssl_options[:key] = env.ssl.client_key if env.ssl.client_key
+            ssl_options[:ssl_version] = env.ssl.version if env.ssl.version
+            ssl_options[:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
+            ssl_options[:min_version] = env.ssl.min_version if env.ssl.min_version
+            ssl_options[:max_version] = env.ssl.max_version if env.ssl.max_version
+            ssl_options
+          end
+        else
+          def ssl_options_from_env(*)
+            {}
+          end
         end
       end
 
@@ -100,32 +139,17 @@ module Faraday
       end
 
       module ReasonPlugin
-        if RUBY_VERSION < "2.5"
-          def self.load_dependencies(*)
-            require "webrick"
-          end
-        else
-          def self.load_dependencies(*)
-            require "net/http/status"
-          end
+        def self.load_dependencies(*)
+          require "net/http/status"
         end
+
         module ResponseMethods
-          if RUBY_VERSION < "2.5"
-            def reason
-              WEBrick::HTTPStatus::StatusMessage.fetch(@status)
-            end
-          else
-            def reason
-              Net::HTTP::STATUS_CODES.fetch(@status)
-            end
+          def reason
+            Net::HTTP::STATUS_CODES.fetch(@status)
           end
         end
       end
 
-      def self.session
-        @session ||= ::HTTPX.plugin(:compression).plugin(:persistent).plugin(ReasonPlugin)
-      end
-
       class ParallelManager
         class ResponseHandler < SimpleDelegator
           attr_reader :env
@@ -158,8 +182,9 @@ module Faraday
 
         include RequestMixin
 
-        def initialize
+        def initialize(options)
           @handlers = []
+          @connection_options = options
         end
 
         def enqueue(request)
@@ -169,85 +194,96 @@ module Faraday
         end
 
         def run
+          return unless @handlers.last
+
           env = @handlers.last.env
 
-          session = HTTPX.session.with(options_from_env(env))
-          session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
-          session = session.plugin(OnDataPlugin) if env.request.stream_response?
+          connect(env) do |session|
+            requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
 
-          requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
+            if env.request.stream_response?
+              requests.each do |request|
+                request.response_on_data = env.request.on_data
+              end
+            end
 
-          if env.request.stream_response?
-            requests.each do |request|
-              request.response_on_data = env.request.on_data
+            responses = session.request(*requests)
+            Array(responses).each_with_index do |response, index|
+              handler = @handlers[index]
+              handler.on_response.call(response)
+              handler.on_complete.call(handler.env)
             end
           end
+        rescue ::HTTPX::TimeoutError => e
+          raise Faraday::TimeoutError, e
+        end
 
-          responses = session.request(*requests)
-          Array(responses).each_with_index do |response, index|
-            handler = @handlers[index]
-            handler.on_response.call(response)
-            handler.on_complete.call(handler.env)
-          end
+        # from Faraday::Adapter#connection
+        def connection(env)
+          conn = build_connection(env)
+          return conn unless block_given?
+
+          yield conn
+        end
+
+        private
+
+        # from Faraday::Adapter#request_timeout
+        def request_timeout(type, options)
+          key = Faraday::Adapter::TIMEOUT_KEYS[type]
+          options[key] || options[:timeout]
         end
       end
 
       self.supports_parallel = true
 
       class << self
-        def setup_parallel_manager
-          ParallelManager.new
+        def setup_parallel_manager(options = {})
+          ParallelManager.new(options)
         end
       end
 
-      def initialize(app, options = {})
-        super(app)
-        @session_options = options
-      end
-
       def call(env)
         super
         if parallel?(env)
           handler = env[:parallel_manager].enqueue(env)
           handler.on_response do |response|
-            response.raise_for_status
-            save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
-              response_headers.merge!(response.headers)
+            if response.is_a?(::HTTPX::Response)
+              save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+                response_headers.merge!(response.headers)
+              end
+            else
+              env[:error] = response.error
+              save_response(env, 0, "", {}, nil)
             end
           end
           return handler
         end
 
-        session = HTTPX.session
-        session = session.with(@session_options) unless @session_options.empty?
-        session = session.with(options_from_env(env))
-        session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
-        session = session.plugin(OnDataPlugin) if env.request.stream_response?
-
-        request = session.build_request(*build_request(env))
-
-        request.response_on_data = env.request.on_data if env.request.stream_response?
-
-        response = session.request(request)
-        response.raise_for_status unless response.is_a?(::HTTPX::Response)
+        response = connect_and_request(env)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
           response_headers.merge!(response.headers)
         end
         @app.call(env)
-      rescue ::HTTPX::TLSError => e
-        raise SSL_ERROR, e
-      rescue Errno::ECONNABORTED,
-             Errno::ECONNREFUSED,
-             Errno::ECONNRESET,
-             Errno::EHOSTUNREACH,
-             Errno::EINVAL,
-             Errno::ENETUNREACH,
-             Errno::EPIPE => e
-        raise CONNECTION_FAILED_ERROR, e
       end
 
       private
 
+      def connect_and_request(env)
+        connect(env) do |session|
+          request = session.build_request(*build_request(env))
+
+          request.response_on_data = env.request.on_data if env.request.stream_response?
+
+          response = session.request(request)
+          # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
+          response.raise_for_status unless response.is_a?(::HTTPX::Response)
+          response
+        end
+      rescue ::HTTPX::TimeoutError => e
+        raise Faraday::TimeoutError, e
+      end
+
       def parallel?(env)
         env[:parallel_manager]
       end