httpx 1.2.6 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fc8cbe89a9d05f24f615e5de7874c65147954cc8d06524955fea9d0e4ef5598
-  data.tar.gz: e97b5febb579cd1c5e035faef9cf0368ab7148882d2ed95a0454b52fd0d31621
+  metadata.gz: 0162427fe818aafee88a35a12a821cf4f1016701f4513835c91556a7e8579e9e
+  data.tar.gz: f559d77efcdbf0e557c28c9a012cb67f45a95de8f8c2fac521800679ea30dc31
 SHA512:
-  metadata.gz: 55631972d465e4ea086dcaced389f7998380f052c369004f45d286d0502c612289dc5a19deff7ca26c9c0cfd6e2c4926ba5e32744c366f18884f97aedb3ad5bf
-  data.tar.gz: 9eb1be90bceb56c335a84b180ae6c7fc065944ae1fd6dab17d9e4802c7fb62c7d3f34d3c98ba41a9cb1b8e503a929eb97cd8a667a9f536090ef266936efb81d9
+  metadata.gz: 1dd2fa825bdaef26137e8c5d993dcb426eab7897adc8570a343863e7842f3732948bdc827c58e1e361bb35b2c1d549b02d89051a592a836a51f39afb95a77263
+  data.tar.gz: 8a64f6fc512fd8fa60d7feeffff6447d3c8a4081fe6494873b4a527f425dad090ca84b810a2a91477b051a4dfeb0bbb12e0563ef37c20e8d5daab05f2a208138

data/doc/release_notes/1_3_0.md

@@ -0,0 +1,18 @@
+# 1.3.0
+
+## Dependencies
+
+`http-2` v1.0.0 is replacing `http-2-next` as the HTTP/2 parser.
+
+`http-2-next` was forked from `http-2` 5 years ago; its improvements have been merged back to `http-2` recently though, so `http-2-next` willl therefore no longer be maintained.
+
+## Improvements
+
+Request-specific options (`:params`, `:form`, `:json` and `:xml`) are now separately kept by the request, which allows them to share `HTTPX::Options`, and reduce the number of copying / allocations.
+
+This means that `HTTPX::Options` will throw an error if you initialize an object which such keys; this should not happen, as this class is considered internal and you should not be using it directly.
+
+## Fixes
+
+* support for the `datadog` gem v2.0.0 in its adapter has been unblocked, now that the gem has been released.
+* loading the `:cookies` plugin was making the `Session#build_request` private.

data/doc/release_notes/1_3_1.md

@@ -0,0 +1,17 @@
+# 1.3.1
+
+## Improvements
+
+* `:request_timeout` will be applied to all HTTP interactions until the final responses returned to the caller. That includes:
+  * all redirect requests/responses (when using the `:follow_redirects` plugin)
+  * all retried requests/responses (when using the `:retries` plugin)
+  * intermediate requests (such as "100-continue")
+* faraday adapter: allow further plugins of internal session (ex: `builder.adapter(:httpx) { |sess| sess.plugin(:follow_redirects) }...`)
+
+## Bugfixes
+
+* fix connection leak on proxy auth failed (407) handling
+* fix busy loop on deferred requests for the duration interval
+* do not further enqueue deferred requests if they have terminated meanwhile.
+* fix busy loop caused by coalescing connections when one of them is on the DNS resolution phase still.
+* faraday adapter: on parallel mode, skip calling `on_complete` when not defined.

data/lib/httpx/adapters/datadog.rb

@@ -142,7 +142,7 @@ module Datadog::Tracing
             @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
           end
 
-          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0.beta1")
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0")
             def propagate_trace_http(digest, headers)
               Datadog::Tracing::Contrib::HTTP.inject(digest, headers)
             end
@@ -195,15 +195,19 @@ module Datadog::Tracing
           # that the tracing logic hasn't been injected yet; in such cases, the approximate
           # initial resolving time is collected from the connection, and used as span start time,
           # and the tracing object in inserted before the on response callback is called.
-          def handle_error(error)
+          def handle_error(error, request = nil)
             return super unless Datadog::Tracing.enabled?
 
             return super unless error.respond_to?(:connection)
 
-            @pending.each do |request|
-              RequestTracer.new(request).call(error.connection.init_time)
+            @pending.each do |req|
+              next if request and request == req
+
+              RequestTracer.new(req).call(error.connection.init_time)
             end
 
+            RequestTracer.new(request).call(error.connection.init_time) if request
+
             super
           end
         end

data/lib/httpx/adapters/faraday.rb

@@ -30,6 +30,7 @@ module Faraday
           end
           @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
 
+          @connection = @config_block.call(@connection) || @connection if @config_block
           @connection
         end
 
@@ -212,7 +213,7 @@ module Faraday
             Array(responses).each_with_index do |response, index|
               handler = @handlers[index]
               handler.on_response.call(response)
-              handler.on_complete.call(handler.env)
+              handler.on_complete.call(handler.env) if handler.on_complete
             end
           end
         rescue ::HTTPX::TimeoutError => e

data/lib/httpx/adapters/webmock.rb

@@ -47,7 +47,7 @@ module WebMock
         end
 
         def build_error_response(request, exception)
-          HTTPX::ErrorResponse.new(request, exception, request.options)
+          HTTPX::ErrorResponse.new(request, exception)
         end
       end
 

data/lib/httpx/connection/http1.rb

@@ -15,7 +15,7 @@ module HTTPX
     attr_accessor :max_concurrent_requests
 
     def initialize(buffer, options)
-      @options = Options.new(options)
+      @options = options
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
       @max_requests = @options.max_requests
       @parser = Parser::HTTP1.new(self)
@@ -146,7 +146,7 @@ module HTTPX
 
       response << chunk
     rescue StandardError => e
-      error_response = ErrorResponse.new(request, e, request.options)
+      error_response = ErrorResponse.new(request, e)
       request.response = error_response
       dispatch
     end
@@ -197,7 +197,7 @@ module HTTPX
       end
     end
 
-    def handle_error(ex)
+    def handle_error(ex, request = nil)
       if (ex.is_a?(EOFError) || ex.is_a?(TimeoutError)) && @request && @request.response &&
          !@request.response.headers.key?("content-length") &&
          !@request.response.headers.key?("transfer-encoding")
@@ -211,11 +211,15 @@ module HTTPX
       if @pipelining
         catch(:called) { disable }
       else
-        @requests.each do |request|
-          emit(:error, request, ex)
+        @requests.each do |req|
+          next if request && request == req
+
+          emit(:error, req, ex)
         end
-        @pending.each do |request|
-          emit(:error, request, ex)
+        @pending.each do |req|
+          next if request && request == req
+
+          emit(:error, req, ex)
         end
       end
     end

data/lib/httpx/connection/http2.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "http/2/next"
+require "http/2"
 
 module HTTPX
   class Connection::HTTP2
     include Callbacks
     include Loggable
 
-    MAX_CONCURRENT_REQUESTS = HTTP2Next::DEFAULT_MAX_CONCURRENT_STREAMS
+    MAX_CONCURRENT_REQUESTS = ::HTTP2::DEFAULT_MAX_CONCURRENT_STREAMS
 
     class Error < Error
       def initialize(id, code)
@@ -25,7 +25,7 @@ module HTTPX
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
-      @options = Options.new(options)
+      @options = options
       @settings = @options.http2_settings
       @pending = []
       @streams = {}
@@ -111,7 +111,7 @@ module HTTPX
       end
       handle(request, stream)
       true
-    rescue HTTP2Next::Error::StreamLimitExceeded
+    rescue ::HTTP2::Error::StreamLimitExceeded
       @pending.unshift(request)
     end
 
@@ -123,7 +123,7 @@ module HTTPX
       end
     end
 
-    def handle_error(ex)
+    def handle_error(ex, request = nil)
       if ex.instance_of?(TimeoutError) && !@handshake_completed && @connection.state != :closed
         @connection.goaway(:settings_timeout, "closing due to settings timeout")
         emit(:close_handshake)
@@ -131,11 +131,15 @@ module HTTPX
         settings_ex.set_backtrace(ex.backtrace)
         ex = settings_ex
       end
-      @streams.each_key do |request|
-        emit(:error, request, ex)
+      @streams.each_key do |req|
+        next if request && request == req
+
+        emit(:error, req, ex)
       end
-      @pending.each do |request|
-        emit(:error, request, ex)
+      @pending.each do |req|
+        next if request && request == req
+
+        emit(:error, req, ex)
       end
     end
 
@@ -168,7 +172,7 @@ module HTTPX
     end
 
     def init_connection
-      @connection = HTTP2Next::Client.new(@settings)
+      @connection = ::HTTP2::Client.new(@settings)
       @connection.on(:frame, &method(:on_frame))
       @connection.on(:frame_sent, &method(:on_frame_sent))
       @connection.on(:frame_received, &method(:on_frame_received))
@@ -309,7 +313,7 @@ module HTTPX
       if error
         ex = Error.new(stream.id, error)
         ex.set_backtrace(caller)
-        response = ErrorResponse.new(request, ex, request.options)
+        response = ErrorResponse.new(request, ex)
         request.response = response
         emit(:response, request, response)
       else

data/lib/httpx/connection.rb

@@ -48,6 +48,8 @@ module HTTPX
     attr_accessor :family
 
     def initialize(uri, options)
+      @origins = [uri.origin]
+      @origin = Utils.to_uri(uri.origin)
       @options = Options.new(options)
       @type = initialize_type(uri, @options)
       @origins = [uri.origin]
@@ -337,7 +339,7 @@ module HTTPX
           #
           loop do
             siz = @io.read(@window_size, @read_buffer)
-            log(level: 3, color: :cyan) { "IO READ: #{siz} bytes..." }
+            log(level: 3, color: :cyan) { "IO READ: #{siz} bytes... (wsize: #{@window_size}, rbuffer: #{@read_buffer.bytesize})" }
             unless siz
               ex = EOFError.new("descriptor closed")
               ex.set_backtrace(caller)
@@ -504,7 +506,7 @@ module HTTPX
         when MisdirectedRequestError
           emit(:misdirected, request)
         else
-          response = ErrorResponse.new(request, ex, @options)
+          response = ErrorResponse.new(request, ex)
           request.response = response
           request.emit(:response, response)
         end
@@ -530,7 +532,7 @@ module HTTPX
       connecting? && callbacks_for?(:connect_error) ? emit(:connect_error, error) : handle_error(error)
       @state = :closed
       emit(:close)
-    rescue TLSError, HTTP2Next::Error::ProtocolError, HTTP2Next::Error::HandshakeError => e
+    rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
       connecting? && callbacks_for?(:connect_error) ? emit(:connect_error, e) : handle_error(e)
@@ -560,6 +562,9 @@ module HTTPX
         emit(:open)
       when :inactive
         return unless @state == :open
+
+        # do not deactivate connection in use
+        return if @inflight.positive?
       when :closing
         return unless @state == :idle || @state == :open
 
@@ -636,7 +641,7 @@ module HTTPX
       end
     end
 
-    def on_error(error)
+    def on_error(error, request = nil)
       if error.instance_of?(TimeoutError)
 
         # inactive connections do not contribute to the select loop, therefore
@@ -650,39 +655,59 @@ module HTTPX
 
         error = error.to_connection_error if connecting?
       end
-      handle_error(error)
+      handle_error(error, request)
       reset
     end
 
-    def handle_error(error)
-      parser.handle_error(error) if @parser && parser.respond_to?(:handle_error)
-      while (request = @pending.shift)
-        response = ErrorResponse.new(request, error, request.options)
-        request.response = response
-        request.emit(:response, response)
+    def handle_error(error, request = nil)
+      parser.handle_error(error, request) if @parser && parser.respond_to?(:handle_error)
+      while (req = @pending.shift)
+        next if request && req == request
+
+        response = ErrorResponse.new(req, error)
+        req.response = response
+        req.emit(:response, response)
       end
+
+      return unless request
+
+      response = ErrorResponse.new(request, error)
+      request.response = response
+      request.emit(:response, response)
     end
 
     def set_request_timeouts(request)
-      write_timeout = request.write_timeout
+      set_request_write_timeout(request)
+      set_request_read_timeout(request)
+      set_request_request_timeout(request)
+    end
+
+    def set_request_read_timeout(request)
       read_timeout = request.read_timeout
-      request_timeout = request.request_timeout
 
-      unless write_timeout.nil? || write_timeout.infinite?
-        set_request_timeout(request, write_timeout, :headers, %i[done response]) do
-          write_timeout_callback(request, write_timeout)
-        end
+      return if read_timeout.nil? || read_timeout.infinite?
+
+      set_request_timeout(request, read_timeout, :done, :response) do
+        read_timeout_callback(request, read_timeout)
       end
+    end
 
-      unless read_timeout.nil? || read_timeout.infinite?
-        set_request_timeout(request, read_timeout, :done, :response) do
-          read_timeout_callback(request, read_timeout)
-        end
+    def set_request_write_timeout(request)
+      write_timeout = request.write_timeout
+
+      return if write_timeout.nil? || write_timeout.infinite?
+
+      set_request_timeout(request, write_timeout, :headers, %i[done response]) do
+        write_timeout_callback(request, write_timeout)
       end
+    end
+
+    def set_request_request_timeout(request)
+      request_timeout = request.request_timeout
 
       return if request_timeout.nil? || request_timeout.infinite?
 
-      set_request_timeout(request, request_timeout, :headers, :response) do
+      set_request_timeout(request, request_timeout, :headers, :complete) do
         read_timeout_callback(request, request_timeout, RequestTimeoutError)
       end
     end
@@ -692,7 +717,8 @@ module HTTPX
 
       @write_buffer.clear
       error = WriteTimeoutError.new(request, nil, write_timeout)
-      on_error(error)
+
+      on_error(error, request)
     end
 
     def read_timeout_callback(request, read_timeout, error_type = ReadTimeoutError)
@@ -702,7 +728,8 @@ module HTTPX
 
       @write_buffer.clear
       error = error_type.new(request, request.response, read_timeout)
-      on_error(error)
+
+      on_error(error, request)
     end
 
     def set_request_timeout(request, timeout, start_event, finish_events, &callback)

data/lib/httpx/io/tcp.rb

@@ -17,7 +17,7 @@ module HTTPX
       @state = :idle
       @addresses = []
       @hostname = origin.host
-      @options = Options.new(options)
+      @options = options
       @fallback_protocol = @options.fallback_protocol
       @port = origin.port
       @interests = :w

data/lib/httpx/io/unix.rb

@@ -12,7 +12,7 @@ module HTTPX
       @addresses = []
       @hostname = origin.host
       @state = :idle
-      @options = Options.new(options)
+      @options = options
       @fallback_protocol = @options.fallback_protocol
       if @options.io
         @io = case @options.io

data/lib/httpx/options.rb

@@ -91,7 +91,7 @@ module HTTPX
     # :debug :: an object which log messages are written to (must respond to <tt><<</tt>)
     # :debug_level :: the log level of messages (can be 1, 2, or 3).
     # :ssl :: a hash of options which can be set as params of OpenSSL::SSL::SSLContext (see HTTPX::IO::SSL)
-    # :http2_settings :: a hash of options to be passed to a HTTP2Next::Connection (ex: <tt>{ max_concurrent_streams: 2 }</tt>)
+    # :http2_settings :: a hash of options to be passed to a HTTP2::Connection (ex: <tt>{ max_concurrent_streams: 2 }</tt>)
     # :fallback_protocol :: version of HTTP protocol to use by default in the absence of protocol negotiation
     #                       like ALPN (defaults to <tt>"http/1.1"</tt>)
     # :supported_compression_formats :: list of compressions supported by the transcoder layer (defaults to <tt>%w[gzip deflate]</tt>).
@@ -124,10 +124,6 @@ module HTTPX
     # :base_path :: path to prefix given relative paths with (ex: "/v2")
     # :max_concurrent_requests :: max number of requests which can be set concurrently
     # :max_requests :: max number of requests which can be made on socket before it reconnects.
-    # :params :: hash or array of key-values which will be encoded and set in the query string of request uris.
-    # :form :: hash of array of key-values which will be form-or-multipart-encoded in requests body payload.
-    # :json :: hash of array of key-values which will be JSON-encoded in requests body payload.
-    # :xml :: Nokogiri XML nodes which will be encoded in requests body payload.
     #
     # This list of options are enhanced with each loaded plugin, see the plugin docs for details.
     def initialize(options = {})
@@ -216,7 +212,7 @@ module HTTPX
     end
 
     %i[
-      params form json xml body ssl http2_settings
+      ssl http2_settings
       request_class response_class headers_class request_body_class
       response_body_class connection_class options_class
       io fallback_protocol debug debug_level resolver_class resolver_options
@@ -224,11 +220,12 @@ module HTTPX
       persistent
     ].each do |method_name|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        # sets +v+ as the value of #{method_name}
         def option_#{method_name}(v); v; end # def option_smth(v); v; end
       OUT
     end
 
-    REQUEST_BODY_IVARS = %i[@headers @params @form @xml @json @body].freeze
+    REQUEST_BODY_IVARS = %i[@headers].freeze
 
     def ==(other)
       super || options_equals?(other)

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -72,6 +72,9 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :aws_profile :: AWS account profile to retrieve credentials from.
       module OptionsMethods
         def option_aws_profile(value)
           String(value)

data/lib/httpx/plugins/aws_sigv4.rb

@@ -12,6 +12,7 @@ module HTTPX
     module AWSSigV4
       Credentials = Struct.new(:username, :password, :security_token)
 
+      # Signs requests using the AWS sigv4 signing.
       class Signer
         def initialize(
           service:,
@@ -149,6 +150,9 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :sigv4_signer :: instance of HTTPX::Plugins::AWSSigV4 used to sign requests.
       module OptionsMethods
         def option_sigv4_signer(value)
           value.is_a?(Signer) ? value : Signer.new(value)
@@ -160,7 +164,7 @@ module HTTPX
           with(sigv4_signer: Signer.new(**options))
         end
 
-        def build_request(*, _)
+        def build_request(*)
           request = super
 
           return request if request.headers.key?("authorization")

data/lib/httpx/plugins/circuit_breaker.rb

@@ -97,6 +97,16 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :circuit_breaker_max_attempts :: the number of attempts the circuit allows, before it is opened (defaults to <tt>3</tt>).
+      # :circuit_breaker_reset_attempts_in :: the time a circuit stays open at most, before it resets (defaults to <tt>60</tt>).
+      # :circuit_breaker_break_on :: callable defining an alternative rule for a response to break
+      #                              (i.e. <tt>->(res) { res.status == 429 } </tt>)
+      # :circuit_breaker_break_in :: the time that must elapse before an open circuit can transit to the half-open state
+      #                              (defaults to <tt><60</tt>).
+      # :circuit_breaker_half_open_drip_rate :: the rate of requests a circuit allows to be performed when in an half-open state
+      #                                         (defaults to <tt>1</tt>).
       module OptionsMethods
         def option_circuit_breaker_max_attempts(value)
           attempts = Integer(value)

data/lib/httpx/plugins/cookies.rb

@@ -40,6 +40,12 @@ module HTTPX
           end
         end
 
+        def build_request(*)
+          request = super
+          request.headers.set_cookie(request.options.cookies[request.uri])
+          request
+        end
+
         private
 
         def on_response(_request, response)
@@ -52,12 +58,6 @@ module HTTPX
 
           super
         end
-
-        def build_request(*, _)
-          request = super
-          request.headers.set_cookie(request.options.cookies[request.uri])
-          request
-        end
       end
 
       module HeadersMethods
@@ -70,6 +70,9 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :cookies :: cookie jar for the session (can be a Hash, an Array, an instance of HTTPX::Plugins::Cookies::CookieJar)
       module OptionsMethods
         def option_headers(*)
           value = super

data/lib/httpx/plugins/digest_auth.rb

@@ -20,6 +20,9 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :digest :: instance of HTTPX::Plugins::Authentication::Digest, used to authenticate requests in the session.
       module OptionsMethods
         def option_digest(value)
           raise TypeError, ":digest must be a #{Authentication::Digest}" unless value.is_a?(Authentication::Digest)

data/lib/httpx/plugins/expect.rb

@@ -20,6 +20,11 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :expect_timeout :: time (in seconds) to wait for a 100-expect response,
+      #                    before retrying without the Expect header (defaults to <tt>2</tt>).
+      # :expect_threshold_size :: min threshold (in bytes) of the request payload to enable the 100-continue negotiation on.
       module OptionsMethods
         def option_expect_timeout(value)
           seconds = Float(value)