httpx 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99138c8286fb426f6bd70a62357cbaf1b54f3ceb030f1ff3c78c9e2bffd8e75a
-  data.tar.gz: 59a28cbadff4830ed047eba007b5f71455b5a8d6aa3e111cfb5897b82b1350fa
+  metadata.gz: 0162427fe818aafee88a35a12a821cf4f1016701f4513835c91556a7e8579e9e
+  data.tar.gz: f559d77efcdbf0e557c28c9a012cb67f45a95de8f8c2fac521800679ea30dc31
 SHA512:
-  metadata.gz: 78b08826c993b9a2c5d1164a2bf6c7bb4123cb9599a1ddc44bd38b827c91da73abf4fee18ae39d67f9370834b3a8d04eb32999cf2c68f9fe654a0605e6d7ca5b
-  data.tar.gz: 6b22a1e473abc7967314785f6fb517bf5d663d87951a7a2cba5855913a348b95dc50e2fddaa801fbcf25aef96b4d7d9b4e4d0dda8388696c0b628ba0c5dd7c1b
+  metadata.gz: 1dd2fa825bdaef26137e8c5d993dcb426eab7897adc8570a343863e7842f3732948bdc827c58e1e361bb35b2c1d549b02d89051a592a836a51f39afb95a77263
+  data.tar.gz: 8a64f6fc512fd8fa60d7feeffff6447d3c8a4081fe6494873b4a527f425dad090ca84b810a2a91477b051a4dfeb0bbb12e0563ef37c20e8d5daab05f2a208138

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

@@ -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/connection/http1.rb

@@ -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

@@ -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
 

data/lib/httpx/connection.rb

@@ -562,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
 
@@ -638,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
@@ -652,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.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
@@ -694,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)
@@ -704,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/options.rb

@@ -220,6 +220,7 @@ 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

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)

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

@@ -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)

data/lib/httpx/plugins/follow_redirects.rb

@@ -4,12 +4,17 @@ module HTTPX
   InsecureRedirectError = Class.new(Error)
   module Plugins
     #
-    # This plugin adds support for following redirect (status 30X) responses.
+    # This plugin adds support for automatically following redirect (status 30X) responses.
     #
-    # It has an upper bound of followed redirects (see *MAX_REDIRECTS*), after which it
-    # will return the last redirect response. It will **not** raise an exception.
+    # It has a default upper bound of followed redirects (see *MAX_REDIRECTS* and the *max_redirects* option),
+    # after which it will return the last redirect response. It will **not** raise an exception.
     #
-    # It also doesn't follow insecure redirects (https -> http) by default (see *follow_insecure_redirects*).
+    # It doesn't follow insecure redirects (https -> http) by default (see *follow_insecure_redirects*).
+    #
+    # It doesn't propagate authorization related headers to requests redirecting to different origins
+    # (see *allow_auth_to_other_origins*) to override.
+    #
+    # It allows customization of when to redirect via the *redirect_on* callback option).
     #
     # https://gitlab.com/os85/httpx/wikis/Follow-Redirects
     #
@@ -20,6 +25,14 @@ module HTTPX
 
       using URIExtensions
 
+      # adds support for the following options:
+      #
+      # :max_redirects :: max number of times a request will be redirected (defaults to <tt>3</tt>).
+      # :follow_insecure_redirects :: whether redirects to an "http://" URI, when coming from an "https//", are allowed
+      #                               (defaults to <tt>false</tt>).
+      # :allow_auth_to_other_origins :: whether auth-related headers, such as "Authorization", are propagated on redirection
+      #                                 (defaults to <tt>false</tt>).
+      # :redirect_on :: optional callback which receives the redirect location and can halt the redirect chain if it returns <tt>false</tt>.
       module OptionsMethods
         def option_max_redirects(value)
           num = Integer(value)
@@ -44,6 +57,7 @@ module HTTPX
       end
 
       module InstanceMethods
+        # returns a session with the *max_redirects* option set to +n+
         def max_redirects(n)
           with(max_redirects: n.to_i)
         end
@@ -133,8 +147,16 @@ module HTTPX
             redirect_after = Utils.parse_retry_after(redirect_after)
 
             log { "redirecting after #{redirect_after} secs..." }
+
+            deactivate_connection(request, connections, options)
+
             pool.after(redirect_after) do
-              send_request(retry_request, connections, options)
+              if request.response
+                # request has terminated abruptly meanwhile
+                retry_request.emit(:response, request.response)
+              else
+                send_request(retry_request, connections, options)
+              end
             end
           else
             send_request(retry_request, connections, options)
@@ -142,6 +164,7 @@ module HTTPX
           nil
         end
 
+        # :nodoc:
         def redirect_request_headers(original_uri, redirect_uri, headers, options)
           headers = headers.dup
 
@@ -156,6 +179,7 @@ module HTTPX
           headers
         end
 
+        # :nodoc:
         def __get_location_from_response(response)
           # @type var location_uri: http_uri
           location_uri = URI(response.headers["location"])
@@ -165,12 +189,15 @@ module HTTPX
       end
 
       module RequestMethods
+        # returns the top-most original HTTPX::Request from the redirect chain
         attr_accessor :root_request
 
+        # returns the follow-up redirect request, or itself
         def redirect_request
           @redirect_request || self
         end
 
+        # sets the follow-up redirect request
         def redirect_request=(req)
           @redirect_request = req
           req.root_request = @root_request || self
@@ -178,7 +205,7 @@ module HTTPX
         end
 
         def response
-          return super unless @redirect_request
+          return super unless @redirect_request && @response.nil?
 
           @redirect_request.response
         end
@@ -187,6 +214,16 @@ module HTTPX
           @options.max_redirects || MAX_REDIRECTS
         end
       end
+
+      module ConnectionMethods
+        private
+
+        def set_request_request_timeout(request)
+          return unless request.root_request.nil?
+
+          super
+        end
+      end
     end
     register_plugin :follow_redirects, FollowRedirects
   end

data/lib/httpx/plugins/proxy/http.rb

@@ -32,9 +32,14 @@ module HTTPX
                !request.headers.key?("proxy-authorization") &&
                response.headers.key?("proxy-authenticate")
 
-              connection = find_connection(request, connections, options)
+              uri = request.uri
 
-              if connection.options.proxy.can_authenticate?(response.headers["proxy-authenticate"])
+              proxy_options = proxy_options(uri, options)
+              connection = connections.find do |conn|
+                conn.match?(uri, proxy_options)
+              end
+
+              if connection && connection.options.proxy.can_authenticate?(response.headers["proxy-authenticate"])
                 request.transition(:idle)
                 request.headers["proxy-authorization"] =
                   connection.options.proxy.authenticate(request, response.headers["proxy-authenticate"])

data/lib/httpx/plugins/proxy.rb

@@ -89,6 +89,10 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :proxy :: proxy options defining *:uri*, *:username*, *:password* or
+      #           *:scheme* (i.e. <tt>{ uri: "http://proxy" }</tt>)
       module OptionsMethods
         def option_proxy(value)
           value.is_a?(Parameters) ? value : Hash[value]
@@ -107,16 +111,29 @@ module HTTPX
         def find_connection(request, connections, options)
           return super unless options.respond_to?(:proxy)
 
-          uri = URI(request.uri)
+          uri = request.uri
 
-          proxy_opts = if (next_proxy = uri.find_proxy)
+          proxy_options = proxy_options(uri, options)
+
+          return super(request, connections, proxy_options) unless proxy_options.proxy
+
+          connection = pool.find_connection(uri, proxy_options) || init_connection(uri, proxy_options)
+          unless connections.nil? || connections.include?(connection)
+            connections << connection
+            set_connection_callbacks(connection, connections, options)
+          end
+          connection
+        end
+
+        def proxy_options(request_uri, options)
+          proxy_opts = if (next_proxy = request_uri.find_proxy)
             { uri: next_proxy }
           else
             proxy = options.proxy
 
-            return super unless proxy
+            return options unless proxy
 
-            return super(request, connections, options.merge(proxy: nil)) unless proxy.key?(:uri)
+            return options.merge(proxy: nil) unless proxy.key?(:uri)
 
             @_proxy_uris ||= Array(proxy[:uri])
 
@@ -133,8 +150,8 @@ module HTTPX
               no_proxy = proxy[:no_proxy]
               no_proxy = no_proxy.join(",") if no_proxy.is_a?(Array)
 
-              return super(request, connections, options.merge(proxy: nil)) unless URI::Generic.use_proxy?(uri.host, next_proxy.host,
-                                                                                                           next_proxy.port, no_proxy)
+              return options.merge(proxy: nil) unless URI::Generic.use_proxy?(request_uri.host, next_proxy.host,
+                                                                              next_proxy.port, no_proxy)
             end
 
             proxy.merge(uri: next_proxy)
@@ -142,13 +159,7 @@ module HTTPX
 
           proxy = Parameters.new(**proxy_opts)
 
-          proxy_options = options.merge(proxy: proxy)
-          connection = pool.find_connection(uri, proxy_options) || init_connection(uri, proxy_options)
-          unless connections.nil? || connections.include?(connection)
-            connections << connection
-            set_connection_callbacks(connection, connections, options)
-          end
-          connection
+          options.merge(proxy: proxy)
         end
 
         def fetch_response(request, connections, options)

data/lib/httpx/plugins/retries.rb

@@ -3,7 +3,12 @@
 module HTTPX
   module Plugins
     #
-    # This plugin adds support for retrying requests when certain errors happen.
+    # This plugin adds support for retrying requests when errors happen.
+    #
+    # It has a default max number of retries (see *MAX_RETRIES* and the *max_retries* option),
+    # after which it will return the last response, error or not. It will **not** raise an exception.
+    #
+    # It does not retry which are not considered idempotent (see *retry_change_requests* to override).
     #
     # https://gitlab.com/os85/httpx/wikis/Retries
     #
@@ -38,6 +43,14 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :max_retries :: max number of times a request will be retried (defaults to <tt>3</tt>).
+      # :retry_change_requests :: whether idempotent requests are retried (defaults to <tt>false</tt>).
+      # :retry_after:: seconds after which a request is retried; can also be a callable object (i.e. <tt>->(req, res) { ... } </tt>)
+      # :retry_jitter :: number of seconds applied to *:retry_after* (must be a callable, i.e. <tt>->(retry_after) { ... } </tt>).
+      # :retry_on :: callable which alternatively defines a different rule for when a response is to be retried
+      #              (i.e. <tt>->(res) { ... }</tt>).
       module OptionsMethods
         def option_retry_after(value)
           # return early if callable
@@ -76,7 +89,7 @@ module HTTPX
 
       module InstanceMethods
         def max_retries(n)
-          with(max_retries: n.to_i)
+          with(max_retries: n)
         end
 
         private
@@ -111,9 +124,17 @@ module HTTPX
 
               retry_start = Utils.now
               log { "retrying after #{retry_after} secs..." }
+
+              deactivate_connection(request, connections, options)
+
               pool.after(retry_after) do
-                log { "retrying (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
-                send_request(request, connections, options)
+                if request.response
+                  # request has terminated abruptly meanwhile
+                  request.emit(:response, request.response)
+                else
+                  log { "retrying (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
+                  send_request(request, connections, options)
+                end
               end
             else
               send_request(request, connections, options)

data/lib/httpx/plugins/ssrf_filter.rb

@@ -87,6 +87,9 @@ module HTTPX
         end
       end
 
+      # adds support for the following options:
+      #
+      # :allowed_schemes :: list of URI schemes allowed (defaults to <tt>["https", "http"]</tt>)
       module OptionsMethods
         def option_allowed_schemes(value)
           Array(value)

data/lib/httpx/pool/synch_pool.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module HTTPX
+  class SynchPool < Pool
+    def initialize(options)
+      super
+
+      @connections = ConnectionStore.new(options)
+    end
+
+    # TODO: #wrap
+    def find_or_new_connection(uri, options, &blk)
+      @connections.find_or_new(uri, options) do |new_conn|
+        catch(:coalesced) do
+          init_connection(new_conn, options)
+          blk.call(new_conn) if blk
+          new_conn
+        end
+      end
+      find_connection(uri, options) || new_connection(uri, options, &blk)
+    end
+
+    class ConnectionManager
+      include Enumerable
+
+      def initialize(limit = 3)
+        @connections = []
+        @used = 0
+        @limit = limit
+      end
+
+      def each(*args, &blk)
+        @connections.each(*args, &blk)
+      end
+
+      def find_or_new(uri, options, &blk)
+        raise "over limit" if @used >= @limit
+
+        @used += 1
+        conn = @connections.find do |connection|
+          connection.match?(uri, options)
+        end
+
+        if conn
+          @connections.delete(conn)
+        else
+          conn = options.connection_class.new(uri, options)
+          blk[conn]
+        end
+
+        conn
+      end
+    end
+
+    class ConnectionStore
+      include Enumerable
+
+      def initialize(options)
+        @connections = Hash.new { |hs, k| hs[k] ||= ConnectionManager.new }
+        @conn_mtx = Thread::Mutex.new
+        @conn_waiter = ConditionVariable.new
+        @timeout = Float(options.fetch(:pool_timeout, 5))
+      end
+
+      def each(&block)
+        return enum_for(__meth__) unless block
+
+        @conn_mtx.synchronize do
+          @connections.each_value do |conns|
+            conns.each(&block)
+          end
+        end
+      end
+
+      def find_or_new(uri, options, &blk)
+        @connections[uri.origin].find_or_new(uri, options, &blk)
+      end
+
+      # def <<(conn)
+      #   @conn_mtx.synchronize do
+      #     origin, conns = @connections.find { |_orig, _| conn.origins.include?(origin) }
+      #     (conns || @connections[conn.origin.to_s]) << conn
+      #   end
+      # end
+
+      def empty?
+        @conn_mtx.synchronize { super }
+      end
+    end
+  end
+end

data/lib/httpx/pool.rb

@@ -108,7 +108,7 @@ module HTTPX
       resolve_connection(connection) unless connection.family
     end
 
-    def deactivate(connections)
+    def deactivate(*connections)
       connections.each do |connection|
         connection.deactivate
         deselect_connection(connection) if connection.state == :inactive

data/lib/httpx/request.rb

@@ -98,17 +98,17 @@ module HTTPX
       @persistent = @options.persistent
     end
 
-    # the read timeout defied for this requet.
+    # the read timeout defined for this requet.
     def read_timeout
       @options.timeout[:read_timeout]
     end
 
-    # the write timeout defied for this requet.
+    # the write timeout defined for this requet.
     def write_timeout
       @options.timeout[:write_timeout]
     end
 
-    # the request timeout defied for this requet.
+    # the request timeout defined for this requet.
     def request_timeout
       @options.timeout[:request_timeout]
     end
@@ -117,10 +117,12 @@ module HTTPX
       @persistent
     end
 
+    # if the request contains trailer headers
     def trailers?
       defined?(@trailers)
     end
 
+    # returns an instance of HTTPX::Headers containing the trailer headers
     def trailers
       @trailers ||= @options.headers_class.new
     end
@@ -132,6 +134,7 @@ module HTTPX
       :w
     end
 
+    # merges +h+ into the instance of HTTPX::Headers of the request.
     def merge_headers(h)
       @headers = @headers.merge(h)
     end

data/lib/httpx/resolver/https.rb

@@ -71,9 +71,11 @@ module HTTPX
         connection = @options.connection_class.new(@uri, @options.merge(ssl: { alpn_protocols: %w[h2] }))
         @pool.init_connection(connection, @options)
         # only explicity emit addresses if connection didn't pre-resolve, i.e. it's not an IP.
-        emit_addresses(connection, @family, @uri_addresses) unless connection.addresses
-        @building_connection = false
-        connection
+        catch(:coalesced) do
+          @building_connection = false
+          emit_addresses(connection, @family, @uri_addresses) unless connection.addresses
+          connection
+        end
       end
     end
 
@@ -199,7 +201,7 @@ module HTTPX
           @queries.delete_if { |_, conn| connection == conn }
 
           Resolver.cached_lookup_set(hostname, @family, addresses) if @resolver_options[:cache]
-          emit_addresses(connection, @family, addresses.map { |addr| addr["data"] })
+          catch(:coalesced) { emit_addresses(connection, @family, addresses.map { |addr| addr["data"] }) }
         end
       end
       return if @connections.empty?

data/lib/httpx/resolver/native.rb

@@ -329,7 +329,7 @@ module HTTPX
           @timeouts.delete(connection.origin.host)
           @connections.delete(connection)
           Resolver.cached_lookup_set(connection.origin.host, @family, addresses) if @resolver_options[:cache]
-          emit_addresses(connection, @family, addresses.map { |addr| addr["data"] })
+          catch(:coalesced) { emit_addresses(connection, @family, addresses.map { |addr| addr["data"] }) }
         end
       end
       return emit(:close) if @connections.empty?

data/lib/httpx/resolver/system.rb

@@ -127,7 +127,7 @@ module HTTPX
           @queries.delete(pair)
 
           family, connection = pair
-          emit_addresses(connection, family, addrs)
+          catch(:coalesced) { emit_addresses(connection, family, addrs) }
         when ERROR
           *pair, error = @pipe_mutex.synchronize { @ips.pop }
           @queries.delete(pair)

data/lib/httpx/session.rb

@@ -125,6 +125,7 @@ module HTTPX
       connection
     end
 
+    # sends the +request+ to the corresponding HTTPX::Connection
     def send_request(request, connections, options = request.options)
       error = catch(:resolve_error) do
         connection = find_connection(request, connections, options)
@@ -231,6 +232,14 @@ module HTTPX
       end
     end
 
+    def deactivate_connection(request, connections, options)
+      conn = connections.find do |c|
+        c.match?(request.uri, options)
+      end
+
+      pool.deactivate(conn) if conn
+    end
+
     # sends an array of HTTPX::Request +requests+, returns the respective array of HTTPX::Response objects.
     def send_requests(*requests)
       connections = _send_requests(requests)
@@ -261,6 +270,7 @@ module HTTPX
           return responses unless request
 
           catch(:coalesced) { pool.next_tick } until (response = fetch_response(request, connections, request.options))
+          request.emit(:complete, response)
 
           responses << response
           requests.shift
@@ -274,14 +284,16 @@ module HTTPX
           # opportunity to traverse the requests, hence we're returning only a fraction of the errors
           # we were supposed to. This effectively fetches the existing responses and return them.
           while (request = requests.shift)
-            responses << fetch_response(request, connections, request.options)
+            response = fetch_response(request, connections, request.options)
+            request.emit(:complete, response) if response
+            responses << response
           end
           break
         end
         responses
       ensure
         if @persistent
-          pool.deactivate(connections)
+          pool.deactivate(*connections)
         else
           close(connections)
         end

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "1.3.0"
+  VERSION = "1.3.1"
 end

data/sig/connection/http1.rbs

@@ -38,7 +38,7 @@ module HTTPX
 
     def consume: () -> void
 
-    def handle_error: (StandardError ex) -> void
+    def handle_error: (StandardError ex, ?Request? request) -> void
 
     def on_start: () -> void
 

data/sig/connection/http2.rbs

@@ -32,7 +32,7 @@ module HTTPX
 
     def consume: () -> void
 
-    def handle_error: (StandardError ex) -> void
+    def handle_error: (StandardError ex, ?Request? request) -> void
 
     def ping: () -> void
 

data/sig/connection.rbs

@@ -119,14 +119,20 @@ module HTTPX
 
     def build_socket: (?Array[ipaddr]? addrs) -> (TCP | SSL | UNIX)
 
-    def on_error: (HTTPX::TimeoutError | Error | StandardError error) -> void
+    def on_error: (HTTPX::TimeoutError | Error | StandardError error, ?Request? request) -> void
 
-    def handle_error: (StandardError error) -> void
+    def handle_error: (StandardError error, ?Request? request) -> void
 
     def purge_after_closed: () -> void
 
     def set_request_timeouts: (Request request) -> void
 
+    def set_request_read_timeout: (Request request) -> void
+
+    def set_request_write_timeout: (Request request) -> void
+
+    def set_request_request_timeout: (Request request) -> void
+
     def write_timeout_callback: (Request request, Numeric write_timeout) -> void
 
     def read_timeout_callback: (Request request, Numeric read_timeout, ?singleton(RequestTimeoutError) error_type) -> void

data/sig/plugins/proxy.rbs

@@ -43,6 +43,8 @@ module HTTPX
         private
 
         def proxy_error?: (Request request, response) -> bool
+
+        def proxy_options: (http_uri request_uri, Options & _ProxyOptions options) -> (Options & _ProxyOptions)
       end
 
       module ConnectionMethods

data/sig/pool.rbs

@@ -19,7 +19,7 @@ module HTTPX
 
     def find_connection: (URI::Generic uri, Options options) -> Connection?
 
-    def deactivate: (*Array[Connection]) -> void
+    def deactivate: (*Connection connections) -> void
 
     private
 

data/sig/resolver/resolver.rbs

@@ -28,7 +28,7 @@ module HTTPX
 
       def initialize: (ip_family? family, Options options) -> void
 
-      def early_resolve: (Connection connection, ?hostname: String) -> void
+      def early_resolve: (Connection connection, ?hostname: String) -> boolish
 
       def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
 

data/sig/session.rbs

@@ -32,6 +32,8 @@ module HTTPX
 
     def find_connection: (Request request, Array[Connection] connections, Options options) -> Connection
 
+    def deactivate_connection: (Request request, Array[Connection] connections, Options options) -> void
+
     def send_request: (Request request, Array[Connection] connections, ?Options options) -> void
 
     def set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options, ?cloned: bool) -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -145,6 +145,7 @@ extra_rdoc_files:
 - doc/release_notes/1_2_5.md
 - doc/release_notes/1_2_6.md
 - doc/release_notes/1_3_0.md
+- doc/release_notes/1_3_1.md
 files:
 - LICENSE.txt
 - README.md
@@ -261,6 +262,7 @@ files:
 - doc/release_notes/1_2_5.md
 - doc/release_notes/1_2_6.md
 - doc/release_notes/1_3_0.md
+- doc/release_notes/1_3_1.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb
@@ -333,6 +335,7 @@ files:
 - lib/httpx/plugins/webdav.rb
 - lib/httpx/pmatch_extensions.rb
 - lib/httpx/pool.rb
+- lib/httpx/pool/synch_pool.rb
 - lib/httpx/punycode.rb
 - lib/httpx/request.rb
 - lib/httpx/request/body.rb
@@ -477,7 +480,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: HTTPX, to the future, and beyond