httpx 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c039169fa319d4e42cff7cb34d8a9cc7fc571e62565f673c32436645780222c
-  data.tar.gz: 6affb65b4fa71aa813cffc498034e0c6a6609bcdb0fca9d0ae9df738d4786d1d
+  metadata.gz: f49b29ea3703f6f40abe3cd82d455235b0a0b50a694bd8fa55839ac471d32bbb
+  data.tar.gz: ce933bb3c35d9434f810d4fc83acb244a1ad0db187123d5f01dcbbbd83622a47
 SHA512:
-  metadata.gz: 21be43709d51f7c50d1624923bc1657c9f096b84686612ff70f660af320d71d94d28a52ccef05f27558d74f22e1fd307944ca8ddf8b6c74c0b322e83eaad9b19
-  data.tar.gz: c551d2b32a71c5bbf099283b3577abe80d5005f702af5edefb79f445296c37c8fb9afb3d52b18db254a0c4ddd115d5f45953549f9b3c99c90ff8b86aedd6cb91
+  metadata.gz: 258cb32129840347a1a37633fb6273133187c98636b63ffcc0b8064f39e3b5642d693ee5da5d7776529625fbe4b68b5193b405c2e0658b2c9b1193b49e316bdc
+  data.tar.gz: 387397ab1954b6abf6a8a54d8764fb25e786fb1bd293401e8afd57f823464f67210527fee0b9e94b34cc3d2931143a5d94598fb6241f5728df77a8f1e045a5bf

data/doc/release_notes/1_6_3.md

@@ -0,0 +1,47 @@
+# 1.6.3
+
+## Features
+
+* allow redacting only headers, or only the body, when using `debug_redact: :headers` or `debug_redact: :body` respectively.
+
+## Improvements
+
+* `system` resolver now works in a non-blocking manner, initiating the dns query in a separate thread and waiting on the pipe after that (it was blocking the main thread during resolution before).
+* reduce allocation to a sinfle shared option object when headers are passed as a session-level option, like `HTTPX.with(headers: geaders).get(...)`
+* privilege using `String#replace` in buffer operations (instead of "clean-then-append").
+* using `Array#unshift` instead of `Array#concat` in order to ensure that request ordering is respected in the face of an in-between error which requires reconnect-and-resend.
+* replaced more internal callback indirection with plain method calls.
+
+
+## Bugfixes
+
+* https: prevent modification of the ssl context object when performing a reconnection.
+* compression: do not return early if the decompression buffer yields an empty string (more frequent under jruby 10).
+* response cache: take query params into account when caching or retrieving cached responses.
+* response cache: do not decompress cached responses on body consumption (the response bodies are cached in plaintext).
+* native resolver: pick next timeout associated with the hostname being resolved (and not the hostnames in the queue).
+* pool: assume that, even when signalled that a connection is available, context may be switched to a session which also checks the same connection out, before it's able to pick it up; in such a case, start from the beginning, until the pool timeout expires.
+* session: forego bookkeeping when a connection is coalesced (instead, allow it to be dropped).
+* digest_auth: make sure that an array is sent back if the probe response fails.
+* alt-svc: when alt-svc handshake happens with more in-flight requests, defer termination to when these requests are made.
+* http2: fix use of unexisting var `ex` when processing the connection closed callback.
+* connection: fix potential session dereferencing, which allowed connections to be used across sessions, therefore bypassing needed synchronization and leading to the `undefined method 'after' for nil:NilClass` error.
+* selector: close only selected connections (instead of all selectable connections) when an error occurs during IO readiness wait calls.
+* resolvers: correctly propagate abrupt termination errors to the connection objects waiting for the answer.
+* resolvers: when errors happenm force-close unresolved connections (and ensure they're both pinned to the corresponding session before the error happens, and are unpinned after error is propagated).
+* resolvers: ensure resolvers transition to "closed" state, on all cases, when any error happens.
+* resolvers: ensure that the next hostname is resolved when a timeout happens on the current one.
+* native resolver: fixed duplication of the hostname to resolve in the list of candidates.
+* https resolver: use a `system` resolver to resolve the DoH server hostname (instead of rerouting it to itself).
+* https resolver: skip loop error reporting when error happens outside of it.
+* https resolver: close connection on resolve errors, which prevents it from being around in the pool after termination; also deactivate it after successful use.
+* multi resolver: do not check resolvers back into the pool if it's a multi resolver and the peer is still resolving (and do the check outside of the critical area).
+* sentry adapter: removed usage of deprecated method which has been removed in sentry-ruby 6.0.0.
+* selector: when coalescing connections, pin the current session before merging connections, to prevent it from registering in a selector being used in a different thread, and inadvertedly allowing it to be used across threads.
+* session: fix: always pin connection before early-or-lazy resolution (fixes connection pool accounting under connection coalescing).
+
+## Chores
+
+* logging emits a timestamp as well (to monitor timeouts).
+* `:stream_bidi` plugin: extends HTTP2 module by using plugin extensions.
+* connection: remove session/selector references when closing a connection (prevents leaking them beyond the usage scope).

data/lib/httpx/adapters/sentry.rb

@@ -32,7 +32,7 @@ module HTTPX::Plugins
 
         return unless config.propagate_traces && config.trace_propagation_targets.any? { |target| url.match?(target) }
 
-        trace = ::Sentry.get_current_client.generate_sentry_trace(sentry_span)
+        trace = sentry_span.to_sentry_trace
         request.headers[::Sentry::SENTRY_TRACE_HEADER_NAME] = trace if trace
       end
 

data/lib/httpx/connection/http1.rb

@@ -44,12 +44,12 @@ module HTTPX
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
-      @pending.concat(@requests) unless @requests.empty?
+      @pending.unshift(*@requests)
     end
 
     def close
       reset
-      emit(:close, true)
+      emit(:close)
     end
 
     def exhausted?
@@ -114,7 +114,7 @@ module HTTPX
                                                      @parser.http_version.join("."),
                                                      headers)
       log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
-      log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{log_redact(v)}" }.join("\n") }
+      log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{log_redact_headers(v)}" }.join("\n") }
 
       @request.response = response
       on_complete if response.finished?
@@ -126,7 +126,7 @@ module HTTPX
       response = @request.response
       log(level: 2) { "trailer headers received" }
 
-      log(color: :yellow) { h.each.map { |f, v| "-> HEADER: #{f}: #{log_redact(v.join(", "))}" }.join("\n") }
+      log(color: :yellow) { h.each.map { |f, v| "-> HEADER: #{f}: #{log_redact_headers(v.join(", "))}" }.join("\n") }
       response.merge_headers(h)
     end
 
@@ -136,7 +136,7 @@ module HTTPX
       return unless request
 
       log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
-      log(level: 2, color: :green) { "-> #{log_redact(chunk.inspect)}" }
+      log(level: 2, color: :green) { "-> #{log_redact_body(chunk.inspect)}" }
       response = request.response
 
       response << chunk
@@ -182,7 +182,7 @@ module HTTPX
       end
 
       if exhausted?
-        @pending.concat(@requests)
+        @pending.unshift(*@requests)
         @requests.clear
 
         emit(:exhausted)
@@ -236,7 +236,7 @@ module HTTPX
       when /keep-alive/i
         if @handshake_completed
           if @max_requests.zero?
-            @pending.concat(@requests)
+            @pending.unshift(*@requests)
             @requests.clear
             emit(:exhausted)
           end
@@ -360,7 +360,7 @@ module HTTPX
 
       while (chunk = request.drain_body)
         log(color: :green) { "<- DATA: #{chunk.bytesize} bytes..." }
-        log(level: 2, color: :green) { "<- #{log_redact(chunk.inspect)}" }
+        log(level: 2, color: :green) { "<- #{log_redact_body(chunk.inspect)}" }
         @buffer << chunk
         throw(:buffer_full, request) if @buffer.full?
       end
@@ -381,7 +381,7 @@ module HTTPX
     def join_headers2(headers)
       headers.each do |field, value|
         field = capitalized(field)
-        log(color: :yellow) { "<- HEADER: #{[field, log_redact(value)].join(": ")}" }
+        log(color: :yellow) { "<- HEADER: #{[field, log_redact_headers(value)].join(": ")}" }
         @buffer << "#{field}: #{value}#{CRLF}"
       end
     end

data/lib/httpx/connection/http2.rb

@@ -89,7 +89,7 @@ module HTTPX
         @connection.goaway
         emit(:timeout, @options.timeout[:close_handshake_timeout])
       end
-      emit(:close, true)
+      emit(:close)
     end
 
     def empty?
@@ -234,12 +234,12 @@ module HTTPX
       extra_headers = set_protocol_headers(request)
 
       if request.headers.key?("host")
-        log { "forbidden \"host\" header found (#{log_redact(request.headers["host"])}), will use it as authority..." }
+        log { "forbidden \"host\" header found (#{log_redact_headers(request.headers["host"])}), will use it as authority..." }
         extra_headers[":authority"] = request.headers["host"]
       end
 
       log(level: 1, color: :yellow) do
-        "\n#{request.headers.merge(extra_headers).each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{log_redact(v)}" }.join("\n")}"
+        "\n#{request.headers.merge(extra_headers).each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")}"
       end
       stream.headers(request.headers.each(extra_headers), end_stream: request.body.empty?)
     end
@@ -251,7 +251,7 @@ module HTTPX
       end
 
       log(level: 1, color: :yellow) do
-        request.trailers.each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{log_redact(v)}" }.join("\n")
+        request.trailers.each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")
       end
       stream.headers(request.trailers.each, end_stream: true)
     end
@@ -279,7 +279,7 @@ module HTTPX
 
     def send_chunk(request, stream, chunk, next_chunk)
       log(level: 1, color: :green) { "#{stream.id}: -> DATA: #{chunk.bytesize} bytes..." }
-      log(level: 2, color: :green) { "#{stream.id}: -> #{log_redact(chunk.inspect)}" }
+      log(level: 2, color: :green) { "#{stream.id}: -> #{log_redact_body(chunk.inspect)}" }
       stream.data(chunk, end_stream: end_stream?(request, next_chunk))
     end
 
@@ -300,7 +300,7 @@ module HTTPX
       end
 
       log(color: :yellow) do
-        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact(v)}" }.join("\n")
+        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")
       end
       _, status = h.shift
       headers = request.options.headers_class.new(h)
@@ -313,14 +313,14 @@ module HTTPX
 
     def on_stream_trailers(stream, response, h)
       log(color: :yellow) do
-        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact(v)}" }.join("\n")
+        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")
       end
       response.merge_headers(h)
     end
 
     def on_stream_data(stream, request, data)
       log(level: 1, color: :green) { "#{stream.id}: <- DATA: #{data.bytesize} bytes..." }
-      log(level: 2, color: :green) { "#{stream.id}: <- #{log_redact(data.inspect)}" }
+      log(level: 2, color: :green) { "#{stream.id}: <- #{log_redact_body(data.inspect)}" }
       request.response << data
     end
 
@@ -387,18 +387,17 @@ module HTTPX
           end
         else
           ex = GoawayError.new(error)
+          ex.set_backtrace(caller)
+
           @pending.unshift(*@streams.keys)
           teardown
-        end
 
-        if ex
-          ex.set_backtrace(caller)
           handle_error(ex)
         end
       end
       return unless is_connection_closed && @streams.empty?
 
-      emit(:close, is_connection_closed)
+      emit(:close) if is_connection_closed
     end
 
     def on_frame_sent(frame)
@@ -409,7 +408,7 @@ module HTTPX
           when :data
             frame.merge(payload: frame[:payload].bytesize)
           when :headers, :ping
-            frame.merge(payload: log_redact(frame[:payload]))
+            frame.merge(payload: log_redact_headers(frame[:payload]))
           else
             frame
           end
@@ -425,7 +424,7 @@ module HTTPX
           when :data
             frame.merge(payload: frame[:payload].bytesize)
           when :headers, :ping
-            frame.merge(payload: log_redact(frame[:payload]))
+            frame.merge(payload: log_redact_headers(frame[:payload]))
           else
             frame
           end
@@ -435,7 +434,7 @@ module HTTPX
 
     def on_altsvc(origin, frame)
       log(level: 2) { "#{frame[:stream]}: altsvc frame was received" }
-      log(level: 2) { "#{frame[:stream]}: #{log_redact(frame.inspect)}" }
+      log(level: 2) { "#{frame[:stream]}: #{log_redact_headers(frame.inspect)}" }
       alt_origin = URI.parse("#{frame[:proto]}://#{frame[:host]}:#{frame[:port]}")
       params = { "ma" => frame[:max_age] }
       emit(:altsvc, origin, alt_origin, origin, params)

data/lib/httpx/connection.rb

@@ -34,8 +34,6 @@ module HTTPX
 
     using URIExtensions
 
-    def_delegator :@io, :closed?
-
     def_delegator :@write_buffer, :empty?
 
     attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling
@@ -48,9 +46,9 @@ module HTTPX
 
     def initialize(uri, options)
       @current_session = @current_selector =
-        @parser = @sibling = @coalesced_connection =
-                    @family = @io = @ssl_session = @timeout =
-                                      @connected_at = @response_received_at = nil
+        @parser = @sibling = @coalesced_connection = @altsvc_connection =
+                               @family = @io = @ssl_session = @timeout =
+                                                 @connected_at = @response_received_at = nil
 
       @exhausted = @cloned = @main_sibling = false
 
@@ -65,7 +63,6 @@ module HTTPX
       @inflight = 0
       @keep_alive_timeout = @options.timeout[:keep_alive_timeout]
 
-      on(:error, &method(:on_error))
       if @options.io
         # if there's an already open IO, get its
         # peer address, and force-initiate the parser
@@ -75,32 +72,6 @@ module HTTPX
       else
         transition(:idle)
       end
-      on(:close) do
-        next if @exhausted # it'll reset
-
-        # may be called after ":close" above, so after the connection has been checked back in.
-        # next unless @current_session
-
-        next unless @current_session
-
-        @current_session.deselect_connection(self, @current_selector, @cloned)
-      end
-      on(:terminate) do
-        next if @exhausted # it'll reset
-
-        current_session = @current_session
-        current_selector = @current_selector
-
-        # may be called after ":close" above, so after the connection has been checked back in.
-        next unless current_session && current_selector
-
-        current_session.deselect_connection(self, current_selector)
-      end
-
-      on(:altsvc) do |alt_origin, origin, alt_params|
-        build_altsvc_connection(alt_origin, origin, alt_params)
-      end
-
       self.addresses = @options.addresses if @options.addresses
     end
 
@@ -158,6 +129,10 @@ module HTTPX
       connection.merge(self)
     end
 
+    def coalesced?
+      @coalesced_connection
+    end
+
     # coalescable connections need to be mergeable!
     # but internally, #mergeable? is called before #coalescable?
     def coalescable?(connection)
@@ -231,7 +206,7 @@ module HTTPX
 
       nil
     rescue StandardError => e
-      emit(:error, e)
+      on_error(e)
       nil
     end
 
@@ -259,7 +234,9 @@ module HTTPX
       nil
     rescue StandardError => e
       @write_buffer.clear
-      emit(:error, e)
+      on_error(e)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      force_close(true)
       raise e
     end
 
@@ -273,7 +250,7 @@ module HTTPX
       case @state
       when :idle
         purge_after_closed
-        emit(:terminate)
+        disconnect
       when :closed
         @connected_at = nil
       end
@@ -281,6 +258,23 @@ module HTTPX
       close
     end
 
+    # bypasses state machine rules while setting the connection in the
+    # :closed state.
+    def force_close(delete_pending = false)
+      if delete_pending
+        @pending.clear
+      elsif (parser = @parser)
+        enqueue_pending_requests_from_parser(parser)
+      end
+      return if @state == :closed
+
+      @state = :closed
+      @write_buffer.clear
+      purge_after_closed
+      disconnect
+      emit(:force_closed, delete_pending)
+    end
+
     # bypasses the state machine to force closing of connections still connecting.
     # **only** used for Happy Eyeballs v2.
     def force_reset(cloned = false)
@@ -368,18 +362,40 @@ module HTTPX
     end
 
     def handle_connect_error(error)
-      return handle_error(error) unless @sibling && @sibling.connecting?
+      return on_error(error) unless @sibling && @sibling.connecting?
 
       @sibling.merge(self)
 
       force_reset(true)
     end
 
+    # disconnects from the current session it's attached to
     def disconnect
-      return unless @current_session && @current_selector
+      return if @exhausted # it'll reset
+
+      return unless (current_session = @current_session) && (current_selector = @current_selector)
 
-      emit(:close)
       @current_session = @current_selector = nil
+
+      current_session.deselect_connection(self, current_selector, @cloned)
+    end
+
+    def on_error(error, request = nil)
+      if error.is_a?(OperationTimeoutError)
+
+        # inactive connections do not contribute to the select loop, therefore
+        # they should not fail due to such errors.
+        return if @state == :inactive
+
+        if @timeout
+          @timeout -= error.timeout
+          return unless @timeout <= 0
+        end
+
+        error = error.to_connection_error if connecting?
+      end
+      handle_error(error, request)
+      reset
     end
 
     # :nocov:
@@ -417,7 +433,11 @@ module HTTPX
           # * the number of pending requests
           # * whether the write buffer has bytes (i.e. for close handshake)
           if @pending.empty? && @inflight.zero? && @write_buffer.empty?
-            log(level: 3) { "NO MORE REQUESTS..." }
+            log(level: 3) { "NO MORE REQUESTS..." } if @parser && @parser.pending.any?
+
+            # terminate if an altsvc connection has been established
+            terminate if @altsvc_connection
+
             return
           end
 
@@ -462,7 +482,14 @@ module HTTPX
             break if @state == :closing || @state == :closed
 
             # exit #consume altogether if all outstanding requests have been dealt with
-            return if @pending.empty? && @inflight.zero?
+            if @pending.empty? && @inflight.zero? && @write_buffer.empty? # rubocop:disable Style/Next
+              log(level: 3) { "NO MORE REQUESTS..." } if @parser && @parser.pending.any?
+
+              # terminate if an altsvc connection has been established
+              terminate if @altsvc_connection
+
+              return
+            end
           end unless ((ints = interests).nil? || ints == :w || @state == :closing) && !epiped
 
           #
@@ -555,6 +582,17 @@ module HTTPX
       request.ping!
     end
 
+    def enqueue_pending_requests_from_parser(parser)
+      parser_pending_requests = parser.pending
+
+      return if parser_pending_requests.empty?
+
+      # the connection will be reused, so parser requests must come
+      # back to the pending list before the parser is reset.
+      @inflight -= parser_pending_requests.size
+      @pending.unshift(*parser_pending_requests)
+    end
+
     def build_parser(protocol = @io.protocol)
       parser = parser_type(protocol).new(@write_buffer, @options)
       set_parser_callbacks(parser)
@@ -564,7 +602,7 @@ module HTTPX
     def set_parser_callbacks(parser)
       parser.on(:response) do |request, response|
         AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
-          emit(:altsvc, alt_origin, origin, alt_params)
+          build_altsvc_connection(alt_origin, origin, alt_params)
         end
         @response_received_at = Utils.now
         @inflight -= 1
@@ -572,7 +610,7 @@ module HTTPX
         request.emit(:response, response)
       end
       parser.on(:altsvc) do |alt_origin, origin, alt_params|
-        emit(:altsvc, alt_origin, origin, alt_params)
+        build_altsvc_connection(alt_origin, origin, alt_params)
       end
 
       parser.on(:pong, &method(:send_pending))
@@ -581,50 +619,31 @@ module HTTPX
         request.emit(:promise, parser, stream)
       end
       parser.on(:exhausted) do
+        enqueue_pending_requests_from_parser(parser)
+
         @exhausted = true
-        current_session = @current_session
-        current_selector = @current_selector
-        begin
-          parser.close
-          @pending.concat(parser.pending)
-        ensure
-          @current_session = current_session
-          @current_selector = current_selector
-        end
+        parser.close
 
-        case @state
-        when :closed
-          idling
-          @exhausted = false
-        when :closing
-          once(:closed) do
-            idling
-            @exhausted = false
-          end
-        end
+        idling
+        @exhausted = false
       end
       parser.on(:origin) do |origin|
         @origins |= [origin]
       end
-      parser.on(:close) do |force|
-        if force
-          reset
-          emit(:terminate)
-        end
+      parser.on(:close) do
+        reset
+        disconnect
       end
       parser.on(:close_handshake) do
-        consume
+        consume unless @state == :closed
       end
       parser.on(:reset) do
-        @pending.concat(parser.pending) unless parser.empty?
-        current_session = @current_session
-        current_selector = @current_selector
+        enqueue_pending_requests_from_parser(parser)
+
         reset
-        unless @pending.empty?
-          idling
-          @current_session = current_session
-          @current_selector = current_selector
-        end
+        # :reset event only fired in http/1.1, so this guarantees
+        # that the connection will be closed here.
+        idling unless @pending.empty?
       end
       parser.on(:current_timeout) do
         @current_timeout = @timeout = parser.timeout
@@ -674,16 +693,12 @@ module HTTPX
       error = ConnectionError.new(e.message)
       error.set_backtrace(e.backtrace)
       handle_connect_error(error) if connecting?
-      @state = :closed
-      purge_after_closed
-      disconnect
+      force_close
     rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
       handle_connect_error(e) if connecting?
-      @state = :closed
-      purge_after_closed
-      disconnect
+      force_close
     end
 
     def handle_transition(nextstate)
@@ -711,6 +726,8 @@ module HTTPX
 
         # do not deactivate connection in use
         return if @inflight.positive? || @parser.waiting_for_ping?
+
+        disconnect
       when :closing
         return unless @state == :idle || @state == :open
 
@@ -785,6 +802,8 @@ module HTTPX
 
     # returns an HTTPX::Connection for the negotiated Alternative Service (or none).
     def build_altsvc_connection(alt_origin, origin, alt_params)
+      return if @altsvc_connection
+
       # do not allow security downgrades on altsvc negotiation
       return if @origin.scheme == "https" && alt_origin.scheme != "https"
 
@@ -802,10 +821,11 @@ module HTTPX
 
       connection.extend(AltSvc::ConnectionMixin) unless connection.is_a?(AltSvc::ConnectionMixin)
 
-      log(level: 1) { "#{origin} alt-svc: #{alt_origin}" }
+      @altsvc_connection = connection
+
+      log(level: 1) { "#{origin}: alt-svc connection##{connection.object_id} established to #{alt_origin}" }
 
       connection.merge(self)
-      terminate
     rescue UnsupportedSchemeError
       altsvc["noop"] = true
       nil
@@ -835,26 +855,8 @@ module HTTPX
       end
     end
 
-    def on_error(error, request = nil)
-      if error.is_a?(OperationTimeoutError)
-
-        # inactive connections do not contribute to the select loop, therefore
-        # they should not fail due to such errors.
-        return if @state == :inactive
-
-        if @timeout
-          @timeout -= error.timeout
-          return unless @timeout <= 0
-        end
-
-        error = error.to_connection_error if connecting?
-      end
-      handle_error(error, request)
-      reset
-    end
-
     def handle_error(error, request = nil)
-      parser.handle_error(error, request) if @parser && parser.respond_to?(:handle_error)
+      parser.handle_error(error, request) if @parser && @parser.respond_to?(:handle_error)
       while (req = @pending.shift)
         next if request && req == request
 
@@ -929,6 +931,17 @@ module HTTPX
 
     def set_request_timeout(label, request, timeout, start_event, finish_events, &callback)
       request.set_timeout_callback(start_event) do
+        unless @current_selector
+          raise Error, "request has been resend to an out-of-session connection, and this " \
+                       "should never happen!!! Please report this error! " \
+                       "(state:#{@state}, " \
+                       "parser?:#{!!@parser}, " \
+                       "bytes in write buffer?:#{!@write_buffer.empty?}, " \
+                       "cloned?:#{@cloned}, " \
+                       "sibling?:#{!!@sibling}, " \
+                       "coalesced?:#{coalesced?})"
+        end
+
         timer = @current_selector.after(timeout, callback)
         request.active_timeouts << label
 

data/lib/httpx/extensions.rb

@@ -4,20 +4,6 @@ require "uri"
 
 module HTTPX
   module ArrayExtensions
-    module FilterMap
-      refine Array do
-        # Ruby 2.7 backport
-        def filter_map
-          return to_enum(:filter_map) unless block_given?
-
-          each_with_object([]) do |item, res|
-            processed = yield(item)
-            res << processed if processed
-          end
-        end
-      end unless Array.method_defined?(:filter_map)
-    end
-
     module Intersect
       refine Array do
         # Ruby 3.1 backport

data/lib/httpx/io/ssl.rb

@@ -98,7 +98,7 @@ module HTTPX
       end
 
       unless @io.is_a?(OpenSSL::SSL::SSLSocket)
-        if (hostname_is_ip = (@ip == @sni_hostname))
+        if (hostname_is_ip = (@ip == @sni_hostname)) && @ctx.verify_hostname
           # IPv6 address would be "[::1]", must turn to "0000:0000:0000:0000:0000:0000:0000:0001" for cert SAN check
           @sni_hostname = @ip.to_string
           # IP addresses in SNI is not valid per RFC 6066, section 3.