httpx 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eece37bd091a7fea17ccc62eca63acaee714c08658d081a938fc38495a4c8813
-  data.tar.gz: 72dcd038803106f08a0317c8d7bc97d22d6cdf5c469ba8f8f9d380d00e8f5ea7
+  metadata.gz: c34100ea496b94c4dbcfcd95330a5c8fa21dd5997d49dff54f62ced363589f7f
+  data.tar.gz: 24ef436a40b17cf4df3b2a9722c36437704c0c2ed1f5a1afc59b16801c36dbb4
 SHA512:
-  metadata.gz: 5af43571f7da30f709883474fb61ef3661b31fa836d249c423726f4815fb7b2bf5c1281e22ca7ad15c00ed26b2ffc950d521b14a9f5c02e7d95d4198b4b986d0
-  data.tar.gz: bd73537be9a610b590d7897cd96f7b6213ece24ea7079ce995a3e05cbee363dcf0f575405ea8d2e612a64737e3bbc70dbdc25ab9a24f5b7e154b9a5187974ffe
+  metadata.gz: 7796301721da3f362b4ec13bf5bffcdec864819dddf404dfb7c7ffadde69508de32e52b85e163b144d4ade6b3579aa256107680332a264b27cbe67fdd9e23875
+  data.tar.gz: 63f47f3e7c9e50b720c8637dabc506fe30e79fb403e6d658646ff6fb894dc02774c8e1c2491d938392f1184d8f26f681361f9ffd1dec6675a622c03ba0441342

data/doc/release_notes/1_8_2.md

@@ -0,0 +1,30 @@
+# 1.8.2
+
+## Improvements
+
+* `:proxy` plugin: allow setting `:no_proxy` option to `"*"` (or `["*"]`) to allow bypassing proxy for all requests.
+* Extending sessions with unknown options will now raise an error, instead of silently ignoring them (consistent with the initialization case now):
+
+```ruby
+session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown option: unknown_option
+```
+
+* Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
+* Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
+* Improve correctness of calling `#dup` on requests and connections.
+
+## Bugfixes
+
+* `:auth` plugin: generate token first, then set the "expires_at" timestamp (bearer tokens, specially if JWT, may carry information about when it expires).
+* `:auth` plugin: do not check for token freshness on a retry, instead force token regeneration.
+* `:retries` plugin: do not apply "retry after" delay after a ping timeout error (the ping timeout already implies a delay, so retry on a new connection should be immediate).
+* `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
+* `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
+* `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
+* native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
+* fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
+* connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
+* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.

data/lib/httpx/adapters/webmock.rb

@@ -34,7 +34,8 @@ module WebMock
         end
 
         def build_from_webmock_response(request, webmock_response)
-          return build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
+          return build_error_response(request,
+                                      HTTPX::RequestTimeoutError.new(request, webmock_response, 1)) if webmock_response.should_timeout
 
           return build_error_response(request, webmock_response.exception) if webmock_response.exception
 

data/lib/httpx/buffer.rb

@@ -46,6 +46,11 @@ module HTTPX
       def_delegator :@buffer, :<<
     end
 
+    def initialize_dup(other)
+      super
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
     def full?
       @buffer.bytesize >= @limit
     end

data/lib/httpx/connection/http1.rb

@@ -29,7 +29,7 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
-      @request = nil
+      @callbacks = @request = nil
       @handshake_completed = @pipelining = false
     end
 

data/lib/httpx/connection/http2.rb

@@ -31,6 +31,7 @@ module HTTPX
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
+      @callbacks = nil
       @options = options
       @settings = @options.http2_settings
       @pending = []
@@ -53,7 +54,7 @@ module HTTPX
     end
 
     def interests
-      if @connection.state == :closed
+      if @connection.closed?
         return unless @handshake_completed
 
         return if @buffer.empty?
@@ -94,7 +95,7 @@ module HTTPX
     end
 
     def close
-      unless @connection.state == :closed
+      unless @connection.closed?
         @connection.goaway
         emit(:timeout, @options.timeout[:close_handshake_timeout])
       end
@@ -102,7 +103,7 @@ module HTTPX
     end
 
     def empty?
-      @connection.state == :closed || @streams.empty?
+      @connection.closed? || @streams.empty?
     end
 
     def exhausted?
@@ -432,7 +433,7 @@ module HTTPX
     end
 
     def on_close(_last_frame, error, _payload)
-      is_connection_closed = @connection.state == :closed
+      is_connection_closed = @connection.closed?
       if error
         @buffer.clear if is_connection_closed
         case error

data/lib/httpx/connection.rb

@@ -36,19 +36,20 @@ module HTTPX
 
     def_delegator :@write_buffer, :empty?
 
-    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling
+    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling,
+                :read_buffer, :write_buffer
 
     attr_writer :current_selector
 
     attr_accessor :current_session, :family
 
-    protected :ssl_session, :sibling
+    protected :ssl_session, :sibling, :read_buffer, :write_buffer
 
     def initialize(uri, options)
       @current_session = @current_selector = @max_concurrent_requests =
                            @parser = @sibling = @coalesced_connection = @altsvc_connection =
-                                                  @ping_timer = @family = @io = @ssl_session =
-                                                                            @timeout = @connected_at = @response_received_at = nil
+                                                  @callbacks = @ping_timer = @family =
+                                                                 @io = @ssl_session = @timeout = @connected_at = @response_received_at = nil
 
       @exhausted = @cloned = @main_sibling = false
 
@@ -76,6 +77,29 @@ module HTTPX
       self.addresses = @options.addresses if @options.addresses
     end
 
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      @callbacks = @parser = @sibling = @coalesced_connection = @altsvc_connection = nil
+      @origins = orig.origins.dup
+      @read_buffer = orig.read_buffer.dup
+      @write_buffer = orig.write_buffer.dup
+      @inflight = 0
+      @pending = []
+      transition(:idle)
+
+      if @io
+        # initialize new IO object with the same set of addresses
+        addresses = @io.addresses
+        @io = nil
+        self.addresses = addresses
+      end
+
+      return unless @current_session && @current_selector
+
+      @current_session.pin(self, @current_selector)
+    end
+
     def peer
       @origin
     end
@@ -148,11 +172,11 @@ module HTTPX
 
     def merge(connection)
       @origins |= connection.instance_variable_get(:@origins)
-      if @ssl_session.nil? && connection.ssl_session
-        @ssl_session = connection.ssl_session
-        @io.session_new_cb do |sess|
-          @ssl_session = sess
-        end if @io
+      if @ssl_session.nil? && (ssl_session = connection.ssl_session)
+        @ssl_session = ssl_session
+        # the socket only needs the merged session if it can still resume it,
+        # i.e. if TLS hasn't been negotiated yet.
+        @io.ssl_session = ssl_session if @io.is_a?(SSL) && !@io.connected?
       end
       connection.purge_pending do |req|
         req.transition(:idle)
@@ -341,7 +365,6 @@ module HTTPX
       end
 
       transition(:closing)
-
       transition(:closed)
     end
 
@@ -775,14 +798,19 @@ module HTTPX
            Errno::ECONNRESET,
            Errno::EADDRNOTAVAIL,
            Errno::EHOSTUNREACH,
-           Errno::EINVAL,
            Errno::ENETUNREACH,
+           Errno::EHOSTDOWN,
+           Errno::ENETDOWN,
+           Errno::EINVAL,
            Errno::EPIPE,
            Errno::ENOENT,
            SocketError,
            IOError => e
       on_connect_error(e)
-    rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
+    rescue TLSError,
+           Errno::ETIMEDOUT,
+           ::HTTP2::Error::ProtocolError,
+           ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
       handle_connect_error(e) if connecting?
@@ -979,6 +1007,8 @@ module HTTPX
 
       parser.ping
 
+      return unless parser.waiting_for_ping?
+
       ping_timeout = @options.timeout[:ping_timeout]
 
       @ping_timer = @current_selector.after(ping_timeout) do

data/lib/httpx/errors.rb

@@ -43,6 +43,9 @@ module HTTPX
     # The HTTPX::Request request object this exception refers to.
     attr_reader :request
 
+    # The response object this exception refers to.
+    attr_reader :response
+
     # initializes the exception with the +request+ and +response+ it refers to, and the
     # +timeout+ causing the error, and the
     def initialize(request, response, timeout)

data/lib/httpx/io/ssl.rb

@@ -6,20 +6,19 @@ module HTTPX
   TLSError = OpenSSL::SSL::SSLError
 
   class SSL < TCP
-    # rubocop:disable Style/MutableConstant
-    TLS_OPTIONS = { alpn_protocols: %w[h2 http/1.1].freeze }
-    # https://github.com/jruby/jruby-openssl/issues/284
+    tls_options = { alpn_protocols: %w[h2 http/1.1].freeze }
     # TODO: remove when dropping support for jruby-openssl < 0.15.4
-    TLS_OPTIONS[:verify_hostname] = true if RUBY_ENGINE == "jruby" && JOpenSSL::VERSION < "0.15.4"
-    # rubocop:enable Style/MutableConstant
-    TLS_OPTIONS.freeze
+    # https://github.com/jruby/jruby-openssl/issues/284
+    tls_options[:verify_hostname] = true if RUBY_ENGINE == "jruby" && JOpenSSL::VERSION < "0.15.4"
+    TLS_OPTIONS = tls_options.freeze
 
     attr_writer :ssl_session
 
     def initialize(_, _, options)
       super
 
-      @ssl_session = nil
+      @ssl_session = @session_new_cb = nil
+
       ctx_options = TLS_OPTIONS
       ctx_options = ctx_options.merge(options.ssl) if options.ssl && !options.ssl.empty?
       @sni_hostname = (ctx_options.delete(:hostname) if ctx_options.key?(:hostname)) || @hostname
@@ -35,6 +34,7 @@ module HTTPX
           @ctx.session_cache_mode =
             OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT | OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE
         end
+        init_session_new_cb
 
         yield(self) if block_given?
       end
@@ -43,14 +43,24 @@ module HTTPX
     end
 
     if OpenSSL::SSL::SSLContext.method_defined?(:session_new_cb=)
+      # sets the ssl session callback to be picked up by the ssl context.
       def session_new_cb(&pr)
-        @ctx.session_new_cb = proc { |_, sess| pr.call(sess) }
+        @session_new_cb = pr
+      end
+
+      # sets the ssl context's new session callback, which points at @session_new_cb when available.
+      def init_session_new_cb
+        @ctx.session_new_cb = proc { |_, sess| @session_new_cb&.call(sess) }
       end
     else
       # session_new_cb not implemented under JRuby
       def session_new_cb; end
+
+      def init_session_new_cb; end
     end
 
+    private :init_session_new_cb
+
     def protocol
       return super unless @io.is_a?(OpenSSL::SSL::SSLSocket)
 

data/lib/httpx/options.rb

@@ -257,12 +257,16 @@ module HTTPX
 
         other_opts = opts_names
       else
-        other_opts = other # : Hash[Symbol, untyped]
+        other_opts = other #: Hash[Symbol, untyped]
         other_opts = Hash[other] unless other.is_a?(Hash)
 
         return self if other_opts.empty?
 
-        return self if other_opts.all? { |opt, v| !respond_to?(opt) || public_send(opt) == v }
+        return self if other_opts.all? do |opt, v|
+          raise Error, "unknown option: #{opt}" unless respond_to?(opt)
+
+          public_send(opt) == v
+        end
       end
 
       opts = dup

data/lib/httpx/plugins/auth.rb

@@ -19,6 +19,8 @@ module HTTPX
       # adds support for the following options:
       #
       # :auth_header_value :: the token to use as a string, or a callable which returns a string when called.
+      #                       the callable is called a request, and a boolean: when true, the user must regenerate a token, otherwise it
+      #                       may probe for token freshness and return the same token.
       # :auth_header_type :: the authentication type to use in the "authorization" header value (i.e. "Bearer", "Digest"...)
       # :auth_header_expires_at :: timestamp at which the auth header will be discarded. should be a callable (like a proc)
       #                            receiving the request as an argument, and should return either a Time object, or an integer (UNIX time).
@@ -96,9 +98,8 @@ module HTTPX
           auth_header_value = @auth_header_value_mtx.synchronize do
             try_invalidate_auth_header_value
 
-            @auth_header_value ||= begin
+            @auth_header_value ||= generate_auth_token(request, false).tap do
               set_auth_header_expires_at(request)
-              generate_auth_token
             end
           end
 
@@ -115,10 +116,10 @@ module HTTPX
           @auth_header_value = @auth_header_expires_at = nil
         end
 
-        def generate_auth_token
+        def generate_auth_token(request, should_regenerate)
           return unless (auth_value = @options.auth_header_value)
 
-          auth_value = auth_value.call(self) if dynamic_auth_token?(auth_value)
+          auth_value = auth_value.call(request, should_regenerate) if dynamic_auth_token?(auth_value)
 
           auth_value
         end
@@ -196,7 +197,7 @@ module HTTPX
             # use whatever was generated for it.
             @auth_header_value_mtx.synchronize do
               if request.auth_token_value == @auth_header_value
-                @auth_header_value = generate_auth_token
+                @auth_header_value = generate_auth_token(request, true)
                 set_auth_header_expires_at(request)
               end
             end

data/lib/httpx/plugins/follow_redirects.rb

@@ -135,9 +135,9 @@ module HTTPX
             return ErrorResponse.new(request, error)
           end
 
-          retry_request = build_request(redirect_method, redirect_uri, redirect_params, options)
+          redirect_request = build_request(redirect_method, redirect_uri, redirect_params, options)
 
-          request.redirect_request = retry_request
+          request.redirect_request = redirect_request
 
           redirect_after = response.headers["retry-after"]
 
@@ -151,24 +151,24 @@ module HTTPX
             redirect_after = Utils.parse_retry_after(redirect_after)
 
             retry_start = Utils.now
-            log { "redirecting after #{redirect_after} secs..." }
+            redirect_request.log { "redirecting after #{redirect_after} secs..." }
             selector.after(redirect_after) do
               if (response = request.response)
                 response.finish!
-                retry_request.response = response
+                redirect_request.response = response
                 # request has terminated abruptly meanwhile
-                retry_request.emit_response(response)
+                redirect_request.emit_response(response)
               else
-                log { "redirecting (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
-                send_request(retry_request, selector, options)
+                redirect_request.log { "redirecting (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
+                send_request(redirect_request, selector, options)
               end
             end
           else
-            send_request(retry_request, selector, options)
+            send_request(redirect_request, selector, options)
 
             # recalling itself, in case an error was triggered by the above, and we can
             # verify retriability again.
-            return fetch_response(request, selector, options)
+            return fetch_response(redirect_request, selector, options)
           end
           nil
         end
@@ -231,6 +231,18 @@ module HTTPX
           @redirect_request.response
         end
 
+        def response=(response)
+          return super unless @redirect_request && @response.nil? # rubocop:disable Lint/ReturnInVoidContext
+
+          @redirect_request.response = response
+        end
+
+        def emit_response(response)
+          return super unless @redirect_request && @response.nil?
+
+          @redirect_request.emit_response(response)
+        end
+
         def max_redirects
           @options.max_redirects || MAX_REDIRECTS
         end

data/lib/httpx/plugins/oauth.rb

@@ -296,9 +296,11 @@ module HTTPX
 
         private
 
-        def generate_auth_token
-          return unless @oauth_session
+        def generate_auth_token(*)
+          return super unless @oauth_session
 
+          # should_regenerate arg ignored, as there's no way to check
+          # for token expiration yet.
           @oauth_session.fetch_access_token(self)
         end
 

data/lib/httpx/plugins/persistent.rb

@@ -18,6 +18,12 @@ module HTTPX
     # https://gitlab.com/os85/httpx/wikis/Persistent
     #
     module Persistent
+      SAFE_REONNECTABLE_ERRORS = [
+        PingTimeoutError,
+        Connection::HTTP2::GoawayError,
+        Connection::HTTP2::PingError,
+      ].freeze
+
       class << self
         def load_dependencies(klass)
           klass.plugin(:fiber_concurrency)
@@ -59,6 +65,15 @@ module HTTPX
           Retries::RECONNECTABLE_ERRORS.any? { |klass| error.is_a?(klass) }
         end
 
+        # whether the error can be safely retried without booking threshold attempts.
+        def safe_reconnectable_error?(error)
+          SAFE_REONNECTABLE_ERRORS.any? { |klass| error.is_a?(klass) }
+        end
+
+        def can_reconnect?(_, response)
+          super || (response.is_a?(ErrorResponse) && safe_reconnectable_error?(response.error))
+        end
+
         def when_to_retry(request, response, *)
           return super unless response.is_a?(ErrorResponse)
 

data/lib/httpx/plugins/proxy.rb

@@ -182,9 +182,11 @@ module HTTPX
           if (no_proxy = proxy.no_proxy)
             no_proxy = no_proxy.join(",") if no_proxy.is_a?(Array)
 
-            # TODO: setting proxy to nil leaks the connection object in the pool
-            return super(request_uri, selector, options.merge(proxy: nil)) unless URI::Generic.use_proxy?(request_uri.host, next_proxy.host,
-                                                                                                          next_proxy.port, no_proxy)
+            unless no_proxy != "*" && # NO_PROXY=* bypasses proxy use
+                   URI::Generic.use_proxy?(request_uri.host, next_proxy.host, next_proxy.port, no_proxy)
+              # TODO: setting proxy to nil leaks the connection object in the pool
+              return super(request_uri, selector, options.merge(proxy: nil))
+            end
           end
 
           super(request_uri, selector, options.merge(proxy: proxy))
@@ -341,6 +343,10 @@ module HTTPX
         module InstanceMethods
           private
 
+          def proxy_error?(request, response, _)
+            super && !request.retries.positive?
+          end
+
           def retryable_error?(ex, *)
             super || ex.is_a?(ProxyConnectionError)
           end

data/lib/httpx/plugins/retries.rb

@@ -29,7 +29,10 @@ module HTTPX
         Errno::ETIMEDOUT,
         ConnectionError,
         TLSError,
-        Connection::HTTP2::Error,
+        Zlib::BufError,
+        PingTimeoutError,
+        Connection::HTTP2::GoawayError,
+        Connection::HTTP2::PingError,
       ].freeze
 
       RETRYABLE_ERRORS = (RECONNECTABLE_ERRORS + [
@@ -148,10 +151,13 @@ module HTTPX
              retryable_response?(response, options)
             try_partial_retry(request, response)
             log { "failed to get response, #{request.retries} tries to go..." }
-            prepare_to_retry(request, response)
 
-            if (retry_after = when_to_retry(request, response, options)) && retry_after.positive?
+            # retry-after must be calculated before prepare_to_retry, as it relies on
+            # state changed byit.
+            retry_after = when_to_retry(request, response, options)
+            prepare_to_retry(request, response)
 
+            if retry_after&.positive?
               retry_start = Utils.now
               log { "retrying after #{retry_after} secs..." }
               selector.after(retry_after) do
@@ -191,13 +197,14 @@ module HTTPX
           RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) } && !ex.is_a?(TotalRequestTimeoutError)
         end
 
-        def proxy_error?(request, response, _)
-          super && !request.retries.positive?
+        def prepare_to_retry(request, response)
+          request.retries -= 1 unless can_reconnect?(request, response)
+          request.transition(:idle)
         end
 
-        def prepare_to_retry(request, _response)
-          request.retries -= 1 unless request.ping? # do not exhaust retries on connection liveness probes
-          request.transition(:idle)
+        # do not exhaust retries on connection liveness probes
+        def can_reconnect?(request, _)
+          request.ping?
         end
 
         def when_to_retry(request, response, options)

data/lib/httpx/plugins/server_sent_events.rb

@@ -146,7 +146,7 @@ module HTTPX
           def when_to_retry(request, *)
             retry_after = request.last_server_sent_message&.retry_after
 
-            retry_after / 1_000.0 if retry_after # original in milliseconds
+            retry_after.to_i / 1_000.0 if retry_after # original in milliseconds
 
             request.last_server_sent_message&.retry_after && super
           end

data/lib/httpx/plugins/tracing.rb

@@ -108,11 +108,13 @@ module HTTPX::Plugins
       def initialize(*)
         super
 
-        @init_time = ::Time.now.utc
+        @init_time = nil
       end
 
       def send_request_to_parser(request)
         if connecting?
+          @init_time ||= ::Time.now.utc
+
           # request span timeframe should include the time it took to connect.
           request.init_time ||= @init_time
         end
@@ -123,13 +125,24 @@ module HTTPX::Plugins
       def idling
         super
 
-        # time of initial request(s) is accounted from the moment
-        # the connection is back to :idle, and ready to connect again.
-        @init_time = ::Time.now.utc
+        @init_time = nil
+      end
+
+      def terminate
+        super
+
+        # ensure that connections which go back to the pool reset their init time.
+        @init_time = nil
       end
 
       private
 
+      def connect
+        @init_time ||= ::Time.now.utc
+
+        super
+      end
+
       def ping(request)
         # if a connection is probed for liveness, the request timeframe should include
         # it too.

data/lib/httpx/request/body.rb

@@ -4,14 +4,17 @@ module HTTPX
   # Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
   class Request::Body < SimpleDelegator
     class << self
-      def new(_, options, body: nil, **params)
-        if body.is_a?(self)
+      def new(h, options, body: nil, **params)
+        case body
+        when self
           # request derives its options from body
           body.options = options.merge(params)
-          return body
+          body
+        when nil
+          super(h, options, **params)
+        else
+          super
         end
-
-        super
       end
     end
 

data/lib/httpx/request.rb

@@ -105,8 +105,8 @@ module HTTPX
 
       @state = :idle
       @connection = @response =
-        @drainer = @peer_address =
-          @informational_status = @on_response_arrived = nil
+        @drainer = @peer_address = @callbacks =
+                     @informational_status = @on_response_arrived = nil
       @ping = @started = false
       @persistent = @options.persistent
       @active_timeouts = []
@@ -115,9 +115,9 @@ module HTTPX
     # dupped initialization
     def initialize_dup(orig)
       super
-      @uri = orig.instance_variable_get(:@uri).dup
       @headers = orig.instance_variable_get(:@headers).dup
       @body = orig.instance_variable_get(:@body).dup
+      @active_timeouts = orig.instance_variable_get(:@active_timeouts).dup
     end
 
     def complete!(response = @response)

data/lib/httpx/resolver/native.rb

@@ -539,6 +539,10 @@ module HTTPX
         return unless @io.connected?
 
         resolve if @queries.empty? && !@connections.empty?
+
+        # #resolve may have closed the resolver already as part of error handling.
+        # @fiber-switch-guard
+        return unless @io
       when :closed
         return if @state == :closed
 

data/lib/httpx/response.rb

@@ -36,10 +36,10 @@ module HTTPX
     # * HTTPX::Response::Body#read
     # * HTTPX::Response::Body#copy_to
     # * HTTPX::Response::Body#close
-    attr_reader  :body
+    attr_reader :body
 
     # The HTTP protocol version used to fetch the response.
-    attr_reader  :version
+    attr_reader :version
 
     # returns the response body buffered in a string.
     def_delegator :@body, :to_s
@@ -68,7 +68,7 @@ module HTTPX
       @headers = @options.headers_class.new(headers)
       @body = @options.response_body_class.new(self, @options)
       @finished = complete?
-      @content_type = @content_length = nil
+      @callbacks = @content_type = @content_length = nil
     end
 
     # dupped initialization

data/lib/httpx/selector.rb

@@ -56,7 +56,7 @@ module HTTPX
 
         begin
           select(timeout) do |c|
-            c.log(level: 2) { "[#{c.state}] selected from selector##{object_id} #{" after #{timeout} secs" unless timeout.nil?}..." }
+            c.log(level: 2) { "[#{c.state}] selected from selector##{object_id}#{" after #{timeout} secs" unless timeout.nil?}..." }
 
             c.call
           end

data/lib/httpx/session.rb

@@ -237,7 +237,7 @@ module HTTPX
 
       return unless response && response.finished?
 
-      log(level: 2) { "response##{response.object_id} fetched" }
+      request.log(level: 2) { "response##{response.object_id} fetched" }
 
       response
     end
@@ -337,6 +337,8 @@ module HTTPX
         end
       end
 
+      log(level: 2) { "waiting to receive #{pending} pending requests..." }
+
       until pending.zero? || selector.empty?
         # loop on selector until at least one response has been received.
         waiting = true
@@ -360,7 +362,8 @@ module HTTPX
         end
       end
 
-      raise Error, "something went wrong, responses not found and requests not resent" unless pending.zero?
+      raise Error, "something went wrong, #{pending} responses not found " \
+                   "and requests not resent" unless pending.zero?
 
       responses
     end

data/lib/httpx/transcoder/json.rb

@@ -51,7 +51,7 @@ module HTTPX::Transcoder
       method(:json_load)
     end
 
-    # rubocop:disable Style/SingleLineMethods
+    # rubocop:disable-next Style/SingleLineMethods
     if defined?(MultiJson)
       def json_load(*args); MultiJson.load(*args); end
       def json_dump(*args); MultiJson.dump(*args); end
@@ -66,6 +66,5 @@ module HTTPX::Transcoder
       def json_load(*args); ::JSON.parse(*args); end
       def json_dump(*args); ::JSON.generate(*args); end
     end
-    # rubocop:enable Style/SingleLineMethods
   end
 end

data/lib/httpx/transcoder/utils/deflater.rb

@@ -55,7 +55,7 @@ module HTTPX
 
       private
 
-      # rubocop:disable Naming/MemoizedInstanceVariableName
+      # rubocop:disable-next Naming/MemoizedInstanceVariableName
       def buffer_deflate!
         return @buffer if defined?(@buffer)
 
@@ -68,7 +68,6 @@ module HTTPX
 
         @buffer = buffer
       end
-      # rubocop:enable Naming/MemoizedInstanceVariableName
     end
   end
 end

data/lib/httpx/version.rb

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

data/sig/connection.rbs

@@ -32,10 +32,11 @@ module HTTPX
     attr_accessor current_session: Session?
     attr_accessor family: Integer?
 
+    attr_reader read_buffer: Buffer
+    attr_reader write_buffer: Buffer
+
 
     @window_size: Integer
-    @read_buffer: Buffer
-    @write_buffer: Buffer
     @inflight: Integer
     @max_concurrent_requests: Integer?
     @keep_alive_timeout: interval?

data/sig/errors.rbs

@@ -31,9 +31,9 @@ module HTTPX
 
   class RequestTimeoutError < TimeoutError
     attr_reader request: Request
-    attr_reader response: response?
+    attr_reader response: untyped
 
-    def initialize: (Request request, response? response, interval timeout) -> void
+    def initialize: (Request request, untyped response, interval timeout) -> void
   end
 
   class ReadTimeoutError < RequestTimeoutError

data/sig/io/ssl.rbs

@@ -9,6 +9,7 @@ module HTTPX
     @ctx: OpenSSL::SSL::SSLContext
     @verify_hostname: bool
     @sni_hostname: String
+    @session_new_cb: (^(OpenSSL::SSL::Session sess) -> void)?
 
     attr_writer ssl_session: OpenSSL::SSL::Session?
 
@@ -24,5 +25,9 @@ module HTTPX
 
     # :nocov:
     def try_ssl_connect: () -> void
+
+    private
+
+    def init_session_new_cb: () -> void
   end
 end

data/sig/plugins/auth.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module Auth
-      type auth_header_value_type = String | ^(Request request) -> string
+      type auth_header_value_type = String | ^(?Request request, ?bool should_regenerate) -> string
 
       interface _AuthOptions
         def auth_header_value: () -> auth_header_value_type?
@@ -18,7 +18,7 @@ module HTTPX
         @auth_header_value_mtx: Thread::Mutex
         @skip_auth_header_value: bool
 
-        def authorization: (?string token, ?auth_header_type: string) ?{ (Request) -> string } -> instance
+        def authorization: (?string token, ?auth_header_type: string) ?{ (?Request, ?bool) -> string } -> instance
 
         def bearer_auth: (?string token) ?{ (Request) -> string } -> instance
 
@@ -28,7 +28,7 @@ module HTTPX
 
         private
 
-        def generate_auth_token: () -> String?
+        def generate_auth_token: (Request & RequestMethods request, bool should_regenerate) -> String?
 
         def dynamic_auth_token?: (auth_header_value_type auth_header_value) -> boolish
       end

data/sig/plugins/persistent.rbs

@@ -1,6 +1,8 @@
 module HTTPX
   module Plugins
     module Persistent
+      SAFE_REONNECTABLE_ERRORS: Array[singleton(StandardError)]
+
       def self.load_dependencies: (singleton(Session)) -> void
 
       def self.extra_options: (Options) -> (Options)
@@ -9,6 +11,8 @@ module HTTPX
         private
 
         def reconnectable_error?: (StandardError error) -> bool
+
+        def safe_reconnectable_error?: (StandardError error) -> bool
       end
     end
 

data/sig/plugins/retries.rbs

@@ -45,9 +45,11 @@ module HTTPX
 
         def try_partial_retry: (retriesRequest request, retriesResponse response) -> void
 
-        def prepare_to_retry: (Request & RequestMethods request, retriesResponse response) -> void
+        def prepare_to_retry: (retriesRequest request, retriesResponse response) -> void
 
-        def when_to_retry: (Request & RequestMethods request, retriesResponse response, retriesOptions options) -> Numeric?
+        def can_reconnect?: (retriesRequest request, retriesResponse response) -> bool
+
+        def when_to_retry: (retriesRequest request, retriesResponse response, retriesOptions options) -> Numeric?
       end
 
       module RequestMethods

data/sig/plugins/tracing.rbs

@@ -30,7 +30,7 @@ module HTTPX
       end
 
       module ConnectionMethods
-        @init_time: Time
+        @init_time: Time?
       end
 
       type retriesRequest = Request & RequestMethods

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -170,6 +170,7 @@ extra_rdoc_files:
 - doc/release_notes/1_7_8.md
 - doc/release_notes/1_8_0.md
 - doc/release_notes/1_8_1.md
+- doc/release_notes/1_8_2.md
 files:
 - LICENSE.txt
 - README.md
@@ -312,6 +313,7 @@ files:
 - doc/release_notes/1_7_8.md
 - doc/release_notes/1_8_0.md
 - doc/release_notes/1_8_1.md
+- doc/release_notes/1_8_2.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb
@@ -557,7 +559,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: HTTPX, to the future, and beyond
 test_files: []