httpx 1.7.3 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54c87d9d8b2be0d12570204fd3c60d37f82127b624dde3a233085d5bcb43778c
-  data.tar.gz: 8bfec9fadfe697d083d37a9317e9ec9d6e23016f174bd62cabf24275f18fee79
+  metadata.gz: 125df778093197c9a1fe8872211cf4085a5a885a40536b58501ce1938f8d28ee
+  data.tar.gz: 5a17b5b02212f65ba3472f4dfda96a017fc1ef9a4fb7a3dce85d7b4ac6a8c6bb
 SHA512:
-  metadata.gz: 2c425e8714c36bdca0ab5d068157caa94ca591829466ccdb888e903487aaab50c9a8756eaa53f1cd692a109160deca10ec9ce4405a7690f38149a9e95ec9fb17
-  data.tar.gz: 20c6ae3067f1fe187402c743fb1741a131ba09e5039ed86e5c5d2eb8c94d590c84644ca3e6ab5fd3948b635d328bba4149df3a1d94dde3dfbf257bd694730275
+  metadata.gz: b6a4014db970d25a1ac51ea73ac5bd828bf8c0f1012ec778abdf054d9dd6dcfe6cf7fc5f73f915a39d74e4e420329e1293e020d63955601e6f669ae6164a016b
+  data.tar.gz: 96b98469fe6194bbd3427adfd1bfc6032be9c44f2c68ff301a6da20a90741b1979aa194c113a11e1b82cb9a54c3559ef7c35b908d41c10297746e438b557eca3

data/doc/release_notes/1_7_4.md

@@ -0,0 +1,42 @@
+# 1.7.4
+
+## Features
+
+### Tracing plugin
+
+A new `:tracing` plugin was introduced. It adds support for a new option, `:tracer`, which accepts an object which responds to the following callbacks:
+
+* `#enabled?(request)` - should return true or false depending on whether tracing is enabled
+* `#start(request)` - called when a request is about to be sent
+* `#finish(request, response)` - called when a response is received
+* `#reset(request)` - called when a request is being prepared to be resent, in cases where it makes sense (i.e. when a request is retried).
+
+You can pass chain several tracers, and callbacks will be relayed to all of them:
+
+```ruby
+HTTP.plugin(:tracing).with(tracer: telemetry_platform_tracer).with(tracer: telemetry2_platform_tracer)
+```
+
+This was developed to be the foundation on top of which the datadag and OTel integrations will be built.
+
+## Improvements
+
+* try fetching response immediately after send the request to the connection; this allows returning from errors much earlier and bug free than doing another round of waits on I/O.
+* when a connection is reconnected, and it was established the first time that the peer can accept only 1 request at a time, the connection will keep that informaation and keep sending requests 1 at a time afterwards.
+
+## Bugfixes
+
+* fix regression from introducing connection post state transition callbacks, by foregoing disconnect when there's pending backlog.
+* transition requests to `:idle` before routing them to a different connection on merge (this could possibly leave dangling timeout callbacks otherwise).
+* `:brotli` plugin was integrated with the stream writer component which allows writing compressed payload in chunks.
+* `:brotli` plugin integrates with the `brotli` gem v0.8.0, which fixed an issue dealing with large payload responses due to the lack of support for decoding payloads in chunks.
+* http1 parser: reset before early returning on `Upgrade` responses (it was left in an invalid "parsing headers", which in the case of a keep-alive connection, would cause the next request to fail being parsed).
+* `datadog` adapter: fixed initialization of the request start time after connections were opened (it was being set to connection initialization time every time, instead of just on the first request before connection is established).
+* parsers: also reroute non-completed in-flight requests back to the connection so they can be retried (previously, only pending requests were).
+* `:proxy` plugin: do not try disconnecting unnecessarily when resetting may already do so (if conditions apply).
+* `:proxy` plugin: removed call to unexisting `#reset!` function.
+* `:proxy` plugin: also close wrapped sockets.
+* connection: on force_close, move connection disconnection logic below so that, if requests are reenqueued from the parser, this can be halted.
+* connection: when transition to `:idle`, reenqueue requests from parser before resetting it.
+* implement `#lazy_resolve` on resolvers, as when they're picked from the selector (instead of from the pool), they may not be wrapped by a Multi proxy.
+* allow resolvers transitioning from `:idle` to `:closed` and forego disconnecting when the resolver is not able to transition to `:closed` (which protects from a possible fiber scheduler context switch which changed the state under the hood).

data/lib/httpx/adapters/datadog.rb

@@ -46,35 +46,25 @@ module Datadog::Tracing
 
           SPAN_REQUEST = "httpx.request"
 
-          # initializes tracing on the +request+.
-          def call(request)
-            return unless configuration(request).enabled
-
-            span = nil
-
-            # request objects are reused, when already buffered requests get rerouted to a different
-            # connection due to connection issues, or when they already got a response, but need to
-            # be retried. In such situations, the original span needs to be extended for the former,
-            # while a new is required for the latter.
-            request.on(:idle) do
-              span = nil
-            end
-            # the span is initialized when the request is buffered in the parser, which is the closest
-            # one gets to actually sending the request.
-            request.on(:headers) do
-              next if span
+          def enabled?(request)
+            configuration(request).enabled
+          end
 
-              span = initialize_span(request, now)
-            end
+          def start(request)
+            request.datadog_span = initialize_span(request, now)
+          end
+
+          def reset(request)
+            request.datadog_span = nil
+          end
 
-            request.on(:response) do |response|
-              span = initialize_span(request, request.init_time) if !span && request.init_time
+          def finish(request, response)
+            request.datadog_span ||= initialize_span(request, request.init_time) if request.init_time
 
-              finish(response, span)
-            end
+            finish_span(response, request.datadog_span)
           end
 
-          def finish(response, span)
+          def finish_span(response, span)
             if response.is_a?(::HTTPX::ErrorResponse)
               span.set_error(response.error)
             else
@@ -137,9 +127,9 @@ module Datadog::Tracing
             ) if Datadog.configuration.tracing.respond_to?(:header_tags)
 
             span
-          rescue StandardError => e
-            Datadog.logger.error("error preparing span for http request: #{e}")
-            Datadog.logger.error(e.backtrace)
+        rescue StandardError => e
+          Datadog.logger.error("error preparing span for http request: #{e}")
+          Datadog.logger.error(e.backtrace)
           end
 
           def now
@@ -179,44 +169,18 @@ module Datadog::Tracing
           end
         end
 
-        module RequestMethods
-          attr_accessor :init_time
-
-          # intercepts request initialization to inject the tracing logic.
-          def initialize(*)
-            super
-
-            @init_time = nil
-
-            return unless Datadog::Tracing.enabled?
-
-            RequestTracer.call(self)
+        class << self
+          def load_dependencies(klass)
+            klass.plugin(:tracing)
           end
 
-          def response=(*)
-            # init_time should be set when it's send to a connection.
-            # However, there are situations where connection initialization fails.
-            # Example is the :ssrf_filter plugin, which raises an error on
-            # initialize if the host is an IP which matches against the known set.
-            # in such cases, we'll just set here right here.
-            @init_time ||= ::Datadog::Core::Utils::Time.now.utc
-
-            super
+          def extra_options(options)
+            options.merge(tracer: RequestTracer)
           end
         end
 
-        module ConnectionMethods
-          def initialize(*)
-            super
-
-            @init_time = ::Datadog::Core::Utils::Time.now.utc
-          end
-
-          def send(request)
-            request.init_time ||= @init_time
-
-            super
-          end
+        module RequestMethods
+          attr_accessor :datadog_span
         end
       end
 

data/lib/httpx/connection/http1.rb

@@ -49,7 +49,12 @@ module HTTPX
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
+      reset_requests
+    end
+
+    def reset_requests
       @pending.unshift(*@requests)
+      @requests.clear
     end
 
     def close
@@ -175,6 +180,7 @@ module HTTPX
 
       if @parser.upgrade?
         response << @parser.upgrade_data
+        @parser.reset!
         throw(:called)
       end
 

data/lib/httpx/connection/http2.rb

@@ -161,6 +161,8 @@ module HTTPX
       @pings.any?
     end
 
+    def reset_requests; end
+
     private
 
     def can_buffer_more_requests?

data/lib/httpx/connection.rb

@@ -45,10 +45,10 @@ module HTTPX
     protected :ssl_session, :sibling
 
     def initialize(uri, options)
-      @current_session = @current_selector =
-        @parser = @sibling = @coalesced_connection = @altsvc_connection =
-                               @family = @io = @ssl_session = @timeout =
-                                                 @connected_at = @response_received_at = nil
+      @current_session = @current_selector = @max_concurrent_requests =
+                           @parser = @sibling = @coalesced_connection = @altsvc_connection =
+                                                  @family = @io = @ssl_session = @timeout =
+                                                                    @connected_at = @response_received_at = nil
 
       @exhausted = @cloned = @main_sibling = false
 
@@ -154,6 +154,7 @@ module HTTPX
         end if @io
       end
       connection.purge_pending do |req|
+        req.transition(:idle)
         send(req)
       end
     end
@@ -161,8 +162,9 @@ module HTTPX
     def purge_pending(&block)
       pendings = []
       if @parser
-        @inflight -= @parser.pending.size
-        pendings << @parser.pending
+        pending = @parser.pending
+        @inflight -= pending.size
+        pendings << pending
       end
       pendings << @pending
       pendings.each do |pending|
@@ -259,16 +261,17 @@ module HTTPX
     # bypasses state machine rules while setting the connection in the
     # :closed state.
     def force_close(delete_pending = false)
+      force_purge
+      return unless @state == :closed
+
       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
+      return unless @pending.empty?
+
       disconnect
       emit(:force_closed, delete_pending)
     end
@@ -284,6 +287,15 @@ module HTTPX
     def reset
       return if @state == :closing || @state == :closed
 
+      parser = @parser
+
+      if parser && parser.respond_to?(:max_concurrent_requests)
+        # if connection being reset has at some downgraded the number of concurrent
+        # requests, such as in the case where an attempt to use HTTP/1 pipelining failed,
+        # keep that information around.
+        @max_concurrent_requests = parser.max_concurrent_requests
+      end
+
       transition(:closing)
 
       transition(:closed)
@@ -326,7 +338,10 @@ module HTTPX
       purge_after_closed
       @write_buffer.clear
       transition(:idle)
-      @parser = nil if @parser
+      return unless @parser
+
+      enqueue_pending_requests_from_parser(parser)
+      @parser = nil
     end
 
     def used?
@@ -378,6 +393,14 @@ module HTTPX
       current_session.deselect_connection(self, current_selector, @cloned)
     end
 
+    def on_connect_error(e)
+      # connect errors, exit gracefully
+      error = ConnectionError.new(e.message)
+      error.set_backtrace(e.backtrace)
+      handle_connect_error(error) if connecting?
+      force_close
+    end
+
     def on_io_error(e)
       on_error(e)
       force_close(true)
@@ -586,6 +609,7 @@ module HTTPX
     end
 
     def enqueue_pending_requests_from_parser(parser)
+      parser.reset_requests # move sequential requests back to pending queue.
       parser_pending_requests = parser.pending
 
       return if parser_pending_requests.empty?
@@ -601,6 +625,7 @@ module HTTPX
     def build_parser(protocol = @io.protocol)
       parser = parser_type(protocol).new(@write_buffer, @options)
       set_parser_callbacks(parser)
+      parser.max_concurrent_requests = @max_concurrent_requests if @max_concurrent_requests && parser.respond_to?(:max_concurrent_requests=)
       parser
     end
 
@@ -637,7 +662,6 @@ module HTTPX
       end
       parser.on(:close) do
         reset
-        disconnect
       end
       parser.on(:close_handshake) do
         consume unless @state == :closed
@@ -694,11 +718,7 @@ module HTTPX
            Errno::ENOENT,
            SocketError,
            IOError => e
-      # connect errors, exit gracefully
-      error = ConnectionError.new(e.message)
-      error.set_backtrace(e.backtrace)
-      handle_connect_error(error) if connecting?
-      force_close
+      on_connect_error(e)
     rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
@@ -729,6 +749,8 @@ module HTTPX
       when :inactive
         return unless @state == :open
 
+        # @type ivar @parser: HTTP1 | HTTP2
+
         # do not deactivate connection in use
         return if @inflight.positive? || @parser.waiting_for_ping?
       when :closing
@@ -748,9 +770,6 @@ module HTTPX
         return unless @write_buffer.empty?
 
         purge_after_closed
-
-        # TODO: should this raise an error instead?
-        return unless @pending.empty?
       when :already_open
         nextstate = :open
         # the first check for given io readiness must still use a timeout.
@@ -769,11 +788,30 @@ module HTTPX
       @state = nextstate
       # post state change
       case nextstate
-      when :closed, :inactive
+      when :inactive
+        disconnect
+      when :closed
+        # TODO: should this raise an error instead?
+        return unless @pending.empty?
+
         disconnect
       end
     end
 
+    def force_purge
+      return if @state == :closed
+
+      @state = :closed
+      @write_buffer.clear
+      begin
+        purge_after_closed
+      rescue IOError
+        # may be raised when closing the socket.
+        # due to connection reuse / fiber scheduling, it may
+        # have been reopened, to bail out in that case.
+      end
+    end
+
     def close_sibling
       return unless @sibling
 

data/lib/httpx/plugins/brotli.rb

@@ -3,11 +3,33 @@
 module HTTPX
   module Plugins
     module Brotli
+      class Error < HTTPX::Error; end
+
       class Deflater < Transcoder::Deflater
+        def initialize(body)
+          @compressor = ::Brotli::Compressor.new
+          super
+        end
+
         def deflate(chunk)
-          return unless chunk
+          return @compressor.process(chunk) << @compressor.flush if chunk
+
+          @compressor.finish
+        end
+      end
+
+      class Inflater
+        def initialize(bytesize)
+          @inflater = ::Brotli::Decompressor.new
+          @bytesize = bytesize
+        end
+
+        def call(chunk)
+          buffer = @inflater.process(chunk)
+          @bytesize -= chunk.bytesize
+          raise Error, "Unexpected end of compressed stream" if @bytesize <= 0 && !@inflater.finished?
 
-          ::Brotli.deflate(chunk)
+          buffer
         end
       end
 
@@ -30,19 +52,25 @@ module HTTPX
       module_function
 
       def load_dependencies(*)
+        gem "brotli", ">= 0.8.0"
         require "brotli"
       end
 
       def self.extra_options(options)
-        options.merge(supported_compression_formats: %w[br] + options.supported_compression_formats)
+        supported_compression_formats = (%w[br] + options.supported_compression_formats).freeze
+        options.merge(
+          supported_compression_formats: supported_compression_formats,
+          headers: options.headers_class.new(options.headers.merge("accept-encoding" => supported_compression_formats))
+        )
       end
 
       def encode(body)
         Deflater.new(body)
       end
 
-      def decode(_response, **)
-        ::Brotli.method(:inflate)
+      def decode(response, bytesize: nil)
+        bytesize ||= response.headers.key?("content-length") ? response.headers["content-length"].to_i : Float::INFINITY
+        Inflater.new(bytesize)
       end
     end
     register_plugin :brotli, Brotli

data/lib/httpx/plugins/expect.rb

@@ -132,7 +132,10 @@ module HTTPX
             request.headers.delete("expect")
             request.transition(:idle)
             send_request(request, selector, options)
-            return
+
+            # recalling itself, in case an error was triggered by the above, and we can
+            # verify retriability again.
+            return fetch_response(request, selector, options)
           end
 
           response

data/lib/httpx/plugins/follow_redirects.rb

@@ -165,6 +165,10 @@ module HTTPX
             end
           else
             send_request(retry_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)
           end
           nil
         end

data/lib/httpx/plugins/h2c.rb

@@ -81,7 +81,7 @@ module HTTPX
           @parser.upgrade(request, response)
           @upgrade_protocol = "h2c"
 
-          prev_parser.requests.each do |req|
+          prev_parser.pending.each do |req|
             req.transition(:idle)
             send(req)
           end

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

@@ -35,7 +35,10 @@ module HTTPX
               request.headers["proxy-authorization"] =
                 options.proxy.authenticate(request, response.headers["proxy-authenticate"])
               send_request(request, selector, options)
-              return
+
+              # recalling itself, in case an error was triggered by the above, and we can
+              # verify retriability again.
+              return fetch_response(request, selector, options)
             end
 
             response
@@ -46,7 +49,7 @@ module HTTPX
           def force_close(*)
             if @state == :connecting
               # proxy connect related requests should not be reenqueed
-              @parser.reset!
+              @parser.reset
               @inflight -= @parser.pending.size
               @parser.pending.clear
             end
@@ -67,18 +70,16 @@ module HTTPX
               return unless @io.connected?
 
               @parser || begin
-                @parser = parser_type(@io.protocol).new(@write_buffer, @options.merge(max_concurrent_requests: 1))
-                parser = @parser
+                @parser = parser = parser_type(@io.protocol).new(@write_buffer, @options.merge(max_concurrent_requests: 1))
                 parser.extend(ProxyParser)
                 parser.on(:response, &method(:__http_on_connect))
                 parser.on(:close) do
                   next unless @parser
 
                   reset
-                  disconnect
                 end
                 parser.on(:reset) do
-                  if parser.empty?
+                  if parser.pending.empty? && parser.empty?
                     reset
                   else
                     enqueue_pending_requests_from_parser(parser)
@@ -94,17 +95,23 @@ module HTTPX
                     # keep parser state around due to proxy auth protocol;
                     # intermediate authenticated request is already inside
                     # the parser
-                    parser = nil
+                    connect_request = parser = nil
 
                     if initial_state == :connecting
                       parser = @parser
                       @parser.reset
+                      if @pending.first.is_a?(ConnectRequest)
+                        connect_request = @pending.shift # this happened when reenqueing
+                      end
                     end
 
                     idling
 
                     @parser = parser
-
+                    if connect_request
+                      @inflight += 1
+                      parser.send(connect_request)
+                    end
                     transition(:connecting)
                   end
                 end

data/lib/httpx/plugins/proxy.rb

@@ -202,7 +202,10 @@ module HTTPX
               log { "failed connecting to proxy, trying next..." }
               request.transition(:idle)
               send_request(request, selector, options)
-              return
+
+              # recalling itself, in case an error was triggered by the above, and we can
+              # verify retriability again.
+              return fetch_response(request, selector, options)
             end
             response
           rescue ProxyError
@@ -320,7 +323,12 @@ module HTTPX
 
         def purge_after_closed
           super
-          @io = @io.proxy_io if @io.respond_to?(:proxy_io)
+
+          while @io.respond_to?(:proxy_io)
+            @io = @io.proxy_io
+
+            super
+          end
         end
       end
 

data/lib/httpx/plugins/retries.rb

@@ -166,11 +166,15 @@ module HTTPX
                   send_request(request, selector, options)
                 end
               end
+
+              return
             else
               send_request(request, selector, options)
-            end
 
-            return
+              # recalling itself, in case an error was triggered by the above, and we can
+              # verify retriability again.
+              return fetch_response(request, selector, options)
+            end
           end
           response
         end

data/lib/httpx/plugins/tracing.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module HTTPX::Plugins
+  #
+  # This plugin adds a simple interface to integrate request tracing SDKs.
+  #
+  # An example of such an integration is the datadog adapter.
+  #
+  # https://gitlab.com/os85/httpx/wikis/Tracing
+  #
+  module Tracing
+    class Wrapper
+      attr_reader :tracers
+      protected :tracers
+
+      def initialize(*tracers)
+        @tracers = tracers.flat_map do |tracer|
+          case tracer
+          when Wrapper
+            tracer.tracers
+          else
+            tracer
+          end
+        end.uniq
+      end
+
+      def merge(tracer)
+        case tracer
+        when Wrapper
+          Wrapper.new(*@tracers, *tracer.tracers)
+        else
+          Wrapper.new(*@tracers, tracer)
+        end
+      end
+
+      def freeze
+        @tracers.each(&:freeze).freeze
+        super
+      end
+
+      %i[start finish reset enabled?].each do |callback|
+        class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+          # proxies ##{callback} calls to wrapper tracers.
+          def #{callback}(*args)                        # def start(*args)
+            @tracers.each { |t| t.#{callback}(*args) }  # @tracers.each { |t| t.start(*args) }
+          end                                           # end
+        OUT
+      end
+    end
+
+    # adds support for the following options:
+    #
+    # :tracer :: object which responds to #start, #finish and #reset.
+    module OptionsMethods
+      private
+
+      def option_tracer(tracer)
+        unless tracer.respond_to?(:start) &&
+               tracer.respond_to?(:finish) &&
+               tracer.respond_to?(:reset) &&
+               tracer.respond_to?(:enabled?)
+          raise TypeError, "#{tracer} must to respond to `#start(r)`, `#finish` and `#reset` and `#enabled?"
+        end
+
+        tracer = Wrapper.new(@tracer, tracer) if @tracer
+        tracer
+      end
+    end
+
+    module RequestMethods
+      attr_accessor :init_time
+
+      # intercepts request initialization to inject the tracing logic.
+      def initialize(*)
+        super
+
+        @init_time = nil
+
+        tracer = @options.tracer
+
+        return unless tracer && tracer.enabled?(self)
+
+        on(:idle) do
+          tracer.reset(self)
+
+          # request is reset when it's retried.
+          @init_time = nil
+        end
+        on(:headers) do
+          # the usual request init time (when not including the connection handshake)
+          # should be the time the request is buffered the first time.
+          @init_time ||= ::Time.now
+
+          tracer.start(self)
+        end
+        on(:response) { |response| tracer.finish(self, response) }
+      end
+
+      def response=(*)
+        # init_time should be set when it's send to a connection.
+        # However, there are situations where connection initialization fails.
+        # Example is the :ssrf_filter plugin, which raises an error on
+        # initialize if the host is an IP which matches against the known set.
+        # in such cases, we'll just set here right here.
+        @init_time ||= ::Time.now
+
+        super
+      end
+    end
+
+    # Connection mixin
+    module ConnectionMethods
+      def initialize(*)
+        super
+
+        @init_time = ::Time.now
+      end
+
+      def send(request)
+        # request init time is only the same as the connection init time
+        # if the connection is going through the connection handshake.
+        request.init_time ||= @init_time unless open?
+
+        super
+      end
+
+      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
+      end
+    end
+  end
+  register_plugin :tracing, Tracing
+end

data/lib/httpx/resolver/multi.rb

@@ -71,14 +71,7 @@ module HTTPX
 
     def lazy_resolve(connection)
       @resolvers.each do |resolver|
-        conn_to_resolve = @current_session.try_clone_connection(connection, @current_selector, resolver.family)
-        resolver << conn_to_resolve
-
-        next if resolver.empty?
-
-        # both the resolver and the connection it's resolving must be pineed to the session
-        @current_session.pin(conn_to_resolve, @current_selector)
-        @current_session.select_resolver(resolver, @current_selector)
+        resolver.lazy_resolve(connection)
       end
     end
 

data/lib/httpx/resolver/native.rb

@@ -529,7 +529,7 @@ module HTTPX
 
         resolve if @queries.empty? && !@connections.empty?
       when :closed
-        return unless @state == :open
+        return if @state == :closed
 
         @io.close if @io
         @start_timeout = nil

data/lib/httpx/resolver/resolver.rb

@@ -143,6 +143,19 @@ module HTTPX
       true
     end
 
+    def lazy_resolve(connection)
+      return unless @current_session && @current_selector
+
+      conn_to_resolve = @current_session.try_clone_connection(connection, @current_selector, @family)
+      self << conn_to_resolve
+
+      return if empty?
+
+      # both the resolver and the connection it's resolving must be pinned to the session
+      @current_session.pin(conn_to_resolve, @current_selector)
+      @current_session.select_resolver(self, @current_selector)
+    end
+
     private
 
     def emit_resolved_connection(connection, addresses, early_resolve)
@@ -186,9 +199,10 @@ module HTTPX
     end
 
     def disconnect
-      return if closed?
-
       close
+
+      return unless closed?
+
       @current_session.deselect_resolver(self, @current_selector)
     end
   end

data/lib/httpx/resolver/system.rb

@@ -116,7 +116,9 @@ module HTTPX
       @current_session.select_resolver(self, @current_selector)
     end
 
-    def early_resolve(connection, **); end
+    def early_resolve(_, **) # rubocop:disable Naming/PredicateMethod
+      false
+    end
 
     def handle_socket_timeout(interval)
       error = HTTPX::ResolveTimeoutError.new(interval, "timed out while waiting on select")

data/lib/httpx/session.rb

@@ -392,7 +392,11 @@ module HTTPX
       resolver = find_resolver_for(connection, selector)
 
       pin(connection, selector)
-      resolver.early_resolve(connection) || resolver.lazy_resolve(connection)
+      early_resolve(resolver, connection) || resolver.lazy_resolve(connection)
+    end
+
+    def early_resolve(resolver, connection)
+      resolver.early_resolve(connection)
     end
 
     def on_resolver_connection(connection, selector)

data/lib/httpx/version.rb

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

data/sig/chainable.rbs

@@ -43,6 +43,7 @@ module HTTPX
               | (:webdav, ?options) -> Plugins::sessionWebDav
               | (:xml, ?options) -> Plugins::sessionXML
               | (:query, ?options) -> Plugins::sessionQuery
+              | (:tracing, ?options) -> Plugins::sessionTracing
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/connection/http1.rbs

@@ -26,6 +26,8 @@ module HTTPX
 
     def reset: () -> void
 
+    def reset_requests: () -> void
+
     def close: () -> void
 
     def empty?: () -> bool

data/sig/connection/http2.rbs

@@ -6,6 +6,7 @@ module HTTPX
     MAX_CONCURRENT_REQUESTS: Integer
 
     attr_reader streams: Hash[Request, ::HTTP2::Stream]
+
     attr_reader pending: Array[Request]
 
     @connection: HTTP2::Client
@@ -43,6 +44,8 @@ module HTTPX
 
     def timeout: () -> Numeric?
 
+    def reset_requests: () -> void
+
     private
 
     def initialize: (Buffer buffer, Options options) -> untyped

data/sig/connection.rbs

@@ -122,6 +122,8 @@ module HTTPX
 
     def on_io_error: (IOError error) -> void
 
+    def on_connect_error: (Exception error) -> void
+
     private
 
     def initialize: (http_uri uri, Options options) -> void
@@ -156,6 +158,8 @@ module HTTPX
 
     def handle_error: (StandardError error, ?Request? request) -> void
 
+    def force_purge: () -> void
+
     def close_sibling: () -> void
 
     def purge_after_closed: () -> void

data/sig/plugins/brotli.rbs

@@ -5,17 +5,22 @@ module HTTPX
 
       def self?.encode: (body_encoder body) -> Deflater
 
-      def self?.decode: (HTTPX::Response response, ?bytesize: Integer) -> Transcoder::_Decoder
+      def self?.decode: (HTTPX::Response response, ?bytesize: Integer | Float) -> Inflater
 
-      class Deflater < Transcoder::Deflater
+      class Error < ::HTTPX::Error
       end
 
-      module RequestBodyClassMethods
-        def initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+      class Deflater < Transcoder::Deflater
+        @compressor: ::Brotli::Compressor
       end
 
-      module ResponseBodyClassMethods
-        def initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> (Transcoder::_Decoder | Transcoder::GZIP::Inflater)
+      class Inflater
+        @inflater: ::Brotli::Decompressor
+        @bytesize: Integer | Float
+
+        def initialize: (Integer | Float bytesize) -> void
+
+        def call: (String chunk) -> String
       end
     end
   end

data/sig/plugins/tracing.rbs

@@ -0,0 +1,41 @@
+module HTTPX
+  module Plugins
+    module Tracing
+      interface _Tracer
+        def enabled?: (retriesRequest request) -> boolish
+
+        def start: (retriesRequest request) -> void
+
+        def reset: (retriesRequest request) -> void
+
+        def finish: (retriesRequest request, response response) -> void
+      end
+
+      class Wrapper
+        include _Tracer
+
+        attr_reader tracers: Array[_Tracer]
+
+        def initialize: (*_Tracer tracers) -> void
+
+        def merge: (instance | _Tracer) -> void
+      end
+
+      interface _RetriesOptions
+        def tracer: () -> _Tracer
+      end
+
+      module RequestMethods
+        attr_accessor init_time: Time?
+      end
+
+      module ConnectionMethods
+        @init_time: Time
+      end
+
+      type retriesRequest = Request & RequestMethods
+    end
+
+    type sessionTracing = Session
+  end
+end

data/sig/resolver/resolver.rbs

@@ -41,6 +41,8 @@ module HTTPX
 
       def early_resolve: (Connection connection, ?hostname: String) -> bool
 
+      def lazy_resolve: (Connection connection) -> void
+
       private
 
       def resolve: (?Connection connection, ?String hostname) -> void

data/sig/resolver/system.rbs

@@ -18,8 +18,6 @@ module HTTPX
 
       def initialize: (Options options) -> void
 
-      def lazy_resolve: (Connection connection) -> void
-
       private
 
       def transition: (Symbol nextstate) -> void

data/sig/response/body.rbs

@@ -43,7 +43,7 @@ module HTTPX
 
     def initialize_inflaters: () -> void
 
-    def self.initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> Transcoder::GZIP::Inflater
+    def self.initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> (Object & Transcoder::_Inflater)
 
     def decode_chunk: (String chunk) -> String
 

data/sig/session.rbs

@@ -66,6 +66,8 @@ module HTTPX
 
     def receive_requests: (Array[Request] requests, Selector selector) -> Array[response]
 
+    def early_resolve: (resolver resolver, Connection connection) -> bool
+
     def resolve_connection: (Connection connection, Selector selector) -> void
 
     def on_resolver_connection: (Connection connection, Selector selector) -> void

data/sig/transcoder/gzip.rbs

@@ -16,7 +16,7 @@ module HTTPX
 
       class Inflater
         @inflater: Zlib::Inflate
-        @bytesize: Integer
+        @bytesize: Integer | Float
 
         def initialize: (Integer | Float bytesize) -> void
 

data/sig/transcoder.rbs

@@ -31,8 +31,6 @@ module HTTPX
     end
 
     interface _Inflater
-      def initialize: (Integer | Float bytesize) -> void
-
       def call: (String chunk) -> String
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.7.3
+  version: 1.7.4
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -163,6 +163,7 @@ extra_rdoc_files:
 - doc/release_notes/1_7_1.md
 - doc/release_notes/1_7_2.md
 - doc/release_notes/1_7_3.md
+- doc/release_notes/1_7_4.md
 files:
 - LICENSE.txt
 - README.md
@@ -298,6 +299,7 @@ files:
 - doc/release_notes/1_7_1.md
 - doc/release_notes/1_7_2.md
 - doc/release_notes/1_7_3.md
+- doc/release_notes/1_7_4.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb
@@ -369,6 +371,7 @@ files:
 - lib/httpx/plugins/ssrf_filter.rb
 - lib/httpx/plugins/stream.rb
 - lib/httpx/plugins/stream_bidi.rb
+- lib/httpx/plugins/tracing.rb
 - lib/httpx/plugins/upgrade.rb
 - lib/httpx/plugins/upgrade/h2.rb
 - lib/httpx/plugins/webdav.rb
@@ -474,6 +477,7 @@ files:
 - sig/plugins/ssrf_filter.rbs
 - sig/plugins/stream.rbs
 - sig/plugins/stream_bidi.rbs
+- sig/plugins/tracing.rbs
 - sig/plugins/upgrade.rbs
 - sig/plugins/upgrade/h2.rbs
 - sig/plugins/webdav.rbs