httpx 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7edc783221b5d919a1c788bf360f0cc2d43ee1556eb893c6b5d377d1bd3b4241
-  data.tar.gz: 14dc4593ae5c46acb33a4f242a0058e75eddec70bd22fdf75c05496240de3abc
+  metadata.gz: b8a0ae955506767cc7b2f0a8134dd920bc937f88aeba2f72f691489e4d2199ab
+  data.tar.gz: 96503529f27fddf76b41250f3a7a0686c93d9d6c1091255275ed1d5b2beada11
 SHA512:
-  metadata.gz: 181bc9e6155708c2d1cdaee3dc7c5c15cd5e2b1ba8d7911b6dd5a79e1cebe38558766ec89d8446483d434c7387e330874a70633b2ed5fb8f6a9d8a3401a4abf4
-  data.tar.gz: 49f57c406a2a5c5be83c018c2151ef2e842c266e93d9609dff15684e662bb25580e7c84e2e96a32d1a45094c9baf8ad18f89dbab1e8235127f4d40429f733572
+  metadata.gz: d16170323b9f5d016f496e848be6b6fb50046402ca644c2a016d05fe1af4a5b045a400b31530c8fa38f85a61351125062edce01bd04c975bc45c3205545aef71
+  data.tar.gz: a800e8814449fcf2d3149aadc5f335f458f7dc7fa537d7c676d8460b6bfcfd1a9cc0a96f3350b9492846fea563fca15605f228ef539b39ef36985df05431d193

data/doc/release_notes/1_4_1.md

@@ -0,0 +1,19 @@
+# 1.4.1
+
+## Bugfixes
+
+* several `datadog` integration bugfixes
+    * only load the `datadog` integration when the `datadog` sdk is loaded (and not other gems that may define the `Datadog` module, like `dogstatsd`)
+    * do not trace if datadog integration is loaded but disabled
+    * distributed headers are now sent along (when the configuration is enabled, which it is by default)
+* fix for handling multiple `GOAWAY` frames coming from the server (node.js servers seem to send multiple frames on connection timeout)
+* fix regression for when a url is used with `httpx` which is not `http://` or `https://` (should raise `HTTPX::UnsupportedSchemaError`)
+* worked around `IO.copy_stream` which was emitting incorrect bytes for HTTP/2 requests which bodies larger than the maximum supported frame size.
+* multipart requests: make sure that a body declared as `Pathname` is opened for reading in binary mode.
+* `webmock` integration: ensure that request events are emitted (such as plugins and integrations relying in it, such as `datadog` and the OTel integration)
+* native resolver: do not propagate successful name resolutions for connections which were already closed.
+* native resolver: fixed name resolution stalling, in a multi-request to multi-origin scenario, when a resolution timeout would happen.
+
+## Chore
+
+* refactor of the happy eyeballs and connection coalescing logic to not rely on callbacks, and instead on instance variable management (makes code more straightforward to read).

data/lib/httpx/adapters/datadog.rb

@@ -27,62 +27,54 @@ module Datadog::Tracing
       # Enables tracing for httpx requests.
       #
       # A span will be created for each request transaction; the span is created lazily only when
-      # receiving a response, and it is fed the start time stored inside the tracer object.
+      # buffering a request, and it is fed the start time stored inside the tracer object.
       #
       module Plugin
-        class RequestTracer
-          include Contrib::HttpAnnotationHelper
+        module RequestTracer
+          extend Contrib::HttpAnnotationHelper
+
+          module_function
 
           SPAN_REQUEST = "httpx.request"
 
-          # initializes the tracer object on the +request+.
-          def initialize(request)
-            @request = request
-            @start_time = nil
+          # 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) { reset }
+            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) { call }
-          end
-
-          # sets up the span start time, while preparing the on response callback.
-          def call(*args)
-            return if @start_time
-
-            start(*args)
+            request.on(:headers) do
+              next if span
 
-            @request.once(:response, &method(:finish))
-          end
+              span = initialize_span(request, now)
+            end
 
-          private
+            request.on(:response) do |response|
+              unless span
+                next unless response.is_a?(::HTTPX::ErrorResponse) && response.error.respond_to?(:connection)
 
-          # just sets the span init time. It can be passed a +start_time+ in cases where
-          # this is collected outside the request transaction.
-          def start(start_time = now)
-            @start_time = start_time
-          end
+                # handles the case when the +error+ happened during name resolution, which means
+                # that the tracing start point hasn't been triggered yet; in such cases, the approximate
+                # initial resolving time is collected from the connection, and used as span start time,
+                # and the tracing object in inserted before the on response callback is called.
+                span = initialize_span(request, response.error.connection.init_time)
 
-          # resets the start time for already finished request transactions.
-          def reset
-            return unless @start_time
+              end
 
-            start
+              finish(response, span)
+            end
           end
 
-          # creates the span from the collected +@start_time+ to what the +response+ state
-          # contains. It also resets internal state to allow this object to be reused.
-          def finish(response)
-            return unless @start_time
-
-            span = initialize_span
-
-            return unless span
-
+          def finish(response, span)
             if response.is_a?(::HTTPX::ErrorResponse)
               span.set_error(response.error)
             else
@@ -92,40 +84,40 @@ module Datadog::Tracing
             end
 
             span.finish
-          ensure
-            @start_time = nil
           end
 
           # return a span initialized with the +@request+ state.
-          def initialize_span
-            verb = @request.verb
-            uri = @request.uri
+          def initialize_span(request, start_time)
+            verb = request.verb
+            uri = request.uri
+
+            config = configuration(request)
 
-            span = create_span(@request)
+            span = create_span(request, config, start_time)
 
             span.resource = verb
 
             # Add additional request specific tags to the span.
 
-            span.set_tag(TAG_URL, @request.path)
+            span.set_tag(TAG_URL, request.path)
             span.set_tag(TAG_METHOD, verb)
 
             span.set_tag(TAG_TARGET_HOST, uri.host)
-            span.set_tag(TAG_TARGET_PORT, uri.port.to_s)
+            span.set_tag(TAG_TARGET_PORT, uri.port)
 
             # Tag as an external peer service
             span.set_tag(TAG_PEER_SERVICE, span.service)
 
-            if configuration[:distributed_tracing]
+            if config[:distributed_tracing]
               propagate_trace_http(
-                Datadog::Tracing.active_trace.to_digest,
-                @request.headers
+                Datadog::Tracing.active_trace,
+                request.headers
               )
             end
 
             # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            if Contrib::Analytics.enabled?(config[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
             end
 
             span
@@ -138,34 +130,34 @@ module Datadog::Tracing
             ::Datadog::Core::Utils::Time.now.utc
           end
 
-          def configuration
-            @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
+          def configuration(request)
+            Datadog.configuration.tracing[:httpx, request.uri.host]
           end
 
           if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0")
-            def propagate_trace_http(digest, headers)
-              Datadog::Tracing::Contrib::HTTP.inject(digest, headers)
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Contrib::HTTP.inject(trace, headers)
             end
 
-            def create_span(request)
+            def create_span(request, configuration, start_time)
               Datadog::Tracing.trace(
                 SPAN_REQUEST,
-                service: service_name(request.uri.host, configuration, Datadog.configuration_for(self)),
+                service: service_name(request.uri.host, configuration),
                 type: TYPE_OUTBOUND,
-                start_time: @start_time
+                start_time: start_time
               )
             end
           else
-            def propagate_trace_http(digest, headers)
-              Datadog::Tracing::Propagation::HTTP.inject!(digest, headers)
+            def propagate_trace_http(trace, headers)
+              Datadog::Tracing::Propagation::HTTP.inject!(trace.to_digest, headers)
             end
 
-            def create_span(request)
+            def create_span(request, configuration, start_time)
               Datadog::Tracing.trace(
                 SPAN_REQUEST,
-                service: service_name(request.uri.host, configuration, Datadog.configuration_for(self)),
+                service: service_name(request.uri.host, configuration),
                 span_type: TYPE_OUTBOUND,
-                start_time: @start_time
+                start_time: start_time
               )
             end
           end
@@ -178,7 +170,7 @@ module Datadog::Tracing
 
             return unless Datadog::Tracing.enabled?
 
-            RequestTracer.new(self)
+            RequestTracer.call(self)
           end
         end
 
@@ -190,26 +182,6 @@ module Datadog::Tracing
 
             @init_time = ::Datadog::Core::Utils::Time.now.utc
           end
-
-          # handles the case when the +error+ happened during name resolution, which meanns
-          # that the tracing logic hasn't been injected yet; in such cases, the approximate
-          # initial resolving time is collected from the connection, and used as span start time,
-          # and the tracing object in inserted before the on response callback is called.
-          def handle_error(error, request = nil)
-            return super unless Datadog::Tracing.enabled?
-
-            return super unless error.respond_to?(:connection)
-
-            @pending.each do |req|
-              next if request and request == req
-
-              RequestTracer.new(req).call(error.connection.init_time)
-            end
-
-            RequestTracer.new(request).call(error.connection.init_time) if request
-
-            super
-          end
         end
       end
 

data/lib/httpx/adapters/webmock.rb

@@ -59,7 +59,9 @@ module WebMock
 
           connection.once(:unmock_connection) do
             unless connection.addresses
-              connection.__send__(:callbacks)[:connect_error].clear
+              # reset Happy Eyeballs, fail early
+              connection.sibling = nil
+
               deselect_connection(connection, selector)
             end
             resolve_connection(connection, selector)
@@ -114,6 +116,10 @@ module WebMock
             response = Plugin.build_from_webmock_response(request, mock_response)
             WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, request_signature, mock_response)
             log { "mocking #{request.uri} with #{mock_response.inspect}" }
+            request.transition(:headers)
+            request.transition(:body)
+            request.transition(:trailers)
+            request.transition(:done)
             request.response = response
             request.emit(:response, response)
             response << mock_response.body.dup unless response.is_a?(HTTPX::ErrorResponse)

data/lib/httpx/connection/http2.rb

@@ -137,7 +137,7 @@ module HTTPX
 
         emit(:error, req, ex)
       end
-      @pending.each do |req|
+      while (req = @pending.shift)
         next if request && request == req
 
         emit(:error, req, ex)

data/lib/httpx/connection.rb

@@ -41,15 +41,17 @@ module HTTPX
 
     def_delegator :@write_buffer, :empty?
 
-    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session
+    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling
 
-    attr_writer :current_selector, :coalesced_connection
+    attr_writer :current_selector
 
     attr_accessor :current_session, :family
 
+    protected :sibling
+
     def initialize(uri, options)
-      @current_session = @current_selector = @coalesced_connection = nil
-      @exhausted = @cloned = false
+      @current_session = @current_selector = @sibling = @coalesced_connection = nil
+      @exhausted = @cloned = @main_sibling = false
 
       @options = Options.new(options)
       @type = initialize_type(uri, @options)
@@ -70,9 +72,6 @@ module HTTPX
       else
         transition(:idle)
       end
-      on(:activate) do
-        @current_session.select_connection(self, @current_selector)
-      end
       on(:close) do
         next if @exhausted # it'll reset
 
@@ -86,10 +85,13 @@ module HTTPX
       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
+        next unless current_session && current_selector
 
-        @current_session.deselect_connection(self, @current_selector)
+        current_session.deselect_connection(self, current_selector)
       end
 
       on(:altsvc) do |alt_origin, origin, alt_params|
@@ -194,6 +196,12 @@ module HTTPX
       end
     end
 
+    def io_connected?
+      return @coalesced_connection.io_connected? if @coalesced_connection
+
+      @io && @io.state == :connected
+    end
+
     def connecting?
       @state == :idle
     end
@@ -342,6 +350,35 @@ module HTTPX
       on_error(error)
     end
 
+    def coalesced_connection=(connection)
+      @coalesced_connection = connection
+
+      close_sibling
+      connection.merge(self)
+    end
+
+    def sibling=(connection)
+      @sibling = connection
+
+      return unless connection
+
+      @main_sibling = connection.sibling.nil?
+
+      return unless @main_sibling
+
+      connection.sibling = self
+    end
+
+    def handle_connect_error(error)
+      @connect_error = error
+
+      return handle_error(error) unless @sibling && @sibling.connecting?
+
+      @sibling.merge(self)
+
+      force_reset(true)
+    end
+
     private
 
     def connect
@@ -531,20 +568,22 @@ module HTTPX
         @exhausted = true
         current_session = @current_session
         current_selector = @current_selector
-        parser.close
-        @pending.concat(parser.pending)
+        begin
+          parser.close
+          @pending.concat(parser.pending)
+        ensure
+          @current_session = current_session
+          @current_selector = current_selector
+        end
+
         case @state
         when :closed
           idling
           @exhausted = false
-          @current_session = current_session
-          @current_selector = current_selector
         when :closing
-          once(:close) do
+          once(:closed) do
             idling
             @exhausted = false
-            @current_session = current_session
-            @current_selector = current_selector
           end
         end
       end
@@ -613,13 +652,13 @@ module HTTPX
       # connect errors, exit gracefully
       error = ConnectionError.new(e.message)
       error.set_backtrace(e.backtrace)
-      connecting? && callbacks_for?(:connect_error) ? emit(:connect_error, error) : handle_error(error)
+      handle_connect_error(error) if connecting?
       @state = :closed
       disconnect
     rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
-      connecting? && callbacks_for?(:connect_error) ? emit(:connect_error, e) : handle_error(e)
+      handle_connect_error(e) if connecting?
       @state = :closed
       disconnect
     end
@@ -634,7 +673,7 @@ module HTTPX
         return if @state == :closed
 
         @io.connect
-        emit(:tcp_open, self) if @io.state == :connected
+        close_sibling if @io.state == :connected
 
         return unless @io.connected?
 
@@ -667,6 +706,7 @@ module HTTPX
 
         purge_after_closed
         disconnect if @pending.empty?
+
       when :already_open
         nextstate = :open
         # the first check for given io readiness must still use a timeout.
@@ -677,11 +717,29 @@ module HTTPX
         return unless @state == :inactive
 
         nextstate = :open
-        emit(:activate)
+
+        # activate
+        @current_session.select_connection(self, @current_selector)
       end
       @state = nextstate
     end
 
+    def close_sibling
+      return unless @sibling
+
+      if @sibling.io_connected?
+        reset
+        # TODO: transition connection to closed
+      end
+
+      unless @sibling.state == :closed
+        merge(@sibling) unless @main_sibling
+        @sibling.force_reset(true)
+      end
+
+      @sibling = nil
+    end
+
     def purge_after_closed
       @io.close if @io
       @read_buffer.clear

data/lib/httpx/plugins/grpc/grpc_encoding.rb

@@ -29,6 +29,8 @@ module HTTPX
 
           buf = outbuf if outbuf
 
+          buf = buf.b if buf.frozen?
+
           buf.prepend([compressed_flag, buf.bytesize].pack("CL>"))
           buf
         end

data/lib/httpx/request/body.rb

@@ -52,7 +52,11 @@ module HTTPX
 
       body = stream(@body)
       if body.respond_to?(:read)
-        ::IO.copy_stream(body, ProcIO.new(block))
+        while (chunk = body.read(16_384))
+          block.call(chunk)
+        end
+        # TODO: use copy_stream once bug is resolved: https://bugs.ruby-lang.org/issues/21131
+        # ::IO.copy_stream(body, ProcIO.new(block))
       elsif body.respond_to?(:each)
         body.each(&block)
       else
@@ -60,6 +64,10 @@ module HTTPX
       end
     end
 
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+
     # if the +@body+ is rewindable, it rewinnds it.
     def rewind
       return if empty?
@@ -142,17 +150,4 @@ module HTTPX
       end
     end
   end
-
-  # Wrapper yielder which can be used with functions which expect an IO writer.
-  class ProcIO
-    def initialize(block)
-      @block = block
-    end
-
-    # Implementation the IO write protocol, which yield the given chunk to +@block+.
-    def write(data)
-      @block.call(data.dup)
-      data.bytesize
-    end
-  end
 end

data/lib/httpx/request.rb

@@ -11,6 +11,8 @@ module HTTPX
     include Callbacks
     using URIExtensions
 
+    ALLOWED_URI_SCHEMES = %w[https http].freeze
+
     # default value used for "user-agent" header, when not overridden.
     USER_AGENT = "httpx.rb/#{VERSION}".freeze # rubocop:disable Style/RedundantFreeze
 
@@ -92,6 +94,8 @@ module HTTPX
         @uri = origin.merge("#{base_path}#{@uri}")
       end
 
+      raise UnsupportedSchemeError, "#{@uri}: #{@uri.scheme}: unsupported URI scheme" unless ALLOWED_URI_SCHEMES.include?(@uri.scheme)
+
       @state = :idle
       @response = nil
       @peer_address = nil
@@ -263,6 +267,8 @@ module HTTPX
         return unless @state == :body
       when :done
         return if @state == :expect
+
+        @body.close
       end
       @state = nextstate
       emit(@state, self)

data/lib/httpx/resolver/https.rb

@@ -82,7 +82,9 @@ module HTTPX
 
       if hostname.nil?
         hostname = connection.peer.host
-        log { "resolver: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}" } if connection.peer.non_ascii_hostname
+        log do
+          "resolver #{FAMILY_TYPES[@record_type]}: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}"
+        end if connection.peer.non_ascii_hostname
 
         hostname = @resolver.generate_candidates(hostname).each do |name|
           @queries[name.to_s] = connection
@@ -90,7 +92,7 @@ module HTTPX
       else
         @queries[hostname] = connection
       end
-      log { "resolver: query #{FAMILY_TYPES[RECORD_TYPES[@family]]} for #{hostname}" }
+      log { "resolver #{FAMILY_TYPES[@record_type]}: query for #{hostname}" }
 
       begin
         request = build_request(hostname)

data/lib/httpx/resolver/native.rb

@@ -63,7 +63,10 @@ module HTTPX
       @ns_index += 1
       nameserver = @nameserver
       if nameserver && @ns_index < nameserver.size
-        log { "resolver: failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})" }
+        log do
+          "resolver #{FAMILY_TYPES[@record_type]}: " \
+            "failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})"
+        end
         transition(:idle)
         @timeouts.clear
       else
@@ -140,17 +143,22 @@ module HTTPX
 
       return unless timeout <= 0
 
+      elapsed_after = @_timeouts[@_timeouts.size - @timeouts[host].size]
       @timeouts[host].shift
 
       if !@timeouts[host].empty?
-        log { "resolver: timeout after #{timeout}s, retry(#{@timeouts[host].first}) #{host}..." }
+        log do
+          "resolver #{FAMILY_TYPES[@record_type]}: timeout after #{elapsed_after}s, retry (with #{@timeouts[host].first}s) #{host}..."
+        end
         # must downgrade to tcp AND retry on same host as last
         downgrade_socket
         resolve(connection, h)
       elsif @ns_index + 1 < @nameserver.size
         # try on the next nameserver
         @ns_index += 1
-        log { "resolver: failed resolving #{host} on nameserver #{@nameserver[@ns_index - 1]} (timeout error)" }
+        log do
+          "resolver #{FAMILY_TYPES[@record_type]}: failed resolving #{host} on nameserver #{@nameserver[@ns_index - 1]} (timeout error)"
+        end
         transition(:idle)
         @timeouts.clear
         resolve(connection, h)
@@ -167,7 +175,8 @@ module HTTPX
         ex = ResolveTimeoutError.new(loop_time, "Timed out while resolving #{connection.peer.host}")
         ex.set_backtrace(ex ? ex.backtrace : caller)
         emit_resolve_error(connection, host, ex)
-        emit(:close, self)
+
+        close_or_resolve
       end
     end
 
@@ -249,15 +258,15 @@ module HTTPX
         hostname, connection = @queries.first
         reset_hostname(hostname, reset_candidates: false)
 
-        unless @queries.value?(connection)
+        if @queries.value?(connection)
+          resolve
+        else
           @connections.delete(connection)
           ex = NativeResolveError.new(connection, connection.peer.host, "name or service not known")
           ex.set_backtrace(ex ? ex.backtrace : caller)
           emit_resolve_error(connection, connection.peer.host, ex)
-          emit(:close, self)
+          close_or_resolve
         end
-
-        resolve
       when :message_truncated
         # TODO: what to do if it's already tcp??
         return if @socket_type == :tcp
@@ -326,7 +335,7 @@ module HTTPX
               transition(:idle)
               transition(:open)
             end
-            log { "resolver: ALIAS #{hostname_alias} for #{name}" }
+            log { "resolver #{FAMILY_TYPES[@record_type]}: ALIAS #{hostname_alias} for #{name}" }
             resolve(connection, hostname_alias)
             return
           end
@@ -338,9 +347,7 @@ module HTTPX
           catch(:coalesced) { emit_addresses(connection, @family, addresses.map { |addr| addr["data"] }) }
         end
       end
-      return emit(:close, self) if @connections.empty?
-
-      resolve
+      close_or_resolve
     end
 
     def resolve(connection = @connections.first, hostname = nil)
@@ -352,7 +359,10 @@ module HTTPX
 
       if hostname.nil?
         hostname = connection.peer.host
-        log { "resolver: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}" } if connection.peer.non_ascii_hostname
+        log do
+          "resolver #{FAMILY_TYPES[@record_type]}: " \
+            "resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}"
+        end if connection.peer.non_ascii_hostname
 
         hostname = generate_candidates(hostname).each do |name|
           @queries[name] = connection
@@ -360,14 +370,14 @@ module HTTPX
       else
         @queries[hostname] = connection
       end
-      log { "resolver: query #{@record_type.name.split("::").last} for #{hostname}" }
+      log { "resolver #{FAMILY_TYPES[@record_type]}: query for #{hostname}" }
       begin
         @write_buffer << encode_dns_query(hostname)
       rescue Resolv::DNS::EncodeError => e
         reset_hostname(hostname, connection: connection)
         @connections.delete(connection)
         emit_resolve_error(connection, hostname, e)
-        emit(:close, self) if @connections.empty?
+        close_or_resolve
       end
     end
 
@@ -397,10 +407,10 @@ module HTTPX
 
       case @socket_type
       when :udp
-        log { "resolver: server: udp://#{ip}:#{port}..." }
+        log { "resolver #{FAMILY_TYPES[@record_type]}: server: udp://#{ip}:#{port}..." }
         UDP.new(ip, port, @options)
       when :tcp
-        log { "resolver: server: tcp://#{ip}:#{port}..." }
+        log { "resolver #{FAMILY_TYPES[@record_type]}: server: tcp://#{ip}:#{port}..." }
         origin = URI("tcp://#{ip}:#{port}")
         TCP.new(origin, [ip], @options)
       end
@@ -463,7 +473,7 @@ module HTTPX
           emit_resolve_error(connection, host, error)
         end
       end
-      emit(:close, self) if @connections.empty?
+      close_or_resolve
     end
 
     def reset_hostname(hostname, connection: @queries.delete(hostname), reset_candidates: true)
@@ -478,5 +488,13 @@ module HTTPX
       # reset timeouts
       @timeouts.delete_if { |h, _| candidates.include?(h) }
     end
+
+    def close_or_resolve
+      if @connections.empty?
+        emit(:close, self)
+      else
+        resolve
+      end
+    end
   end
 end

data/lib/httpx/resolver/resolver.rb

@@ -72,17 +72,21 @@ module HTTPX
       # double emission check, but allow early resolution to work
       return if !early_resolve && connection.addresses && !addresses.intersect?(connection.addresses)
 
-      log { "resolver: answer #{FAMILY_TYPES[RECORD_TYPES[family]]} #{connection.peer.host}: #{addresses.inspect}" }
+      log do
+        "resolver #{FAMILY_TYPES[RECORD_TYPES[family]]}: " \
+          "answer #{FAMILY_TYPES[RECORD_TYPES[family]]} #{connection.peer.host}: #{addresses.inspect}"
+      end
+
       if @current_selector && # if triggered by early resolve, session may not be here yet
          !connection.io &&
          connection.options.ip_families.size > 1 &&
          family == Socket::AF_INET &&
          addresses.first.to_s != connection.peer.host.to_s
-        log { "resolver: A response, applying resolution delay..." }
+        log { "resolver #{FAMILY_TYPES[RECORD_TYPES[family]]}: applying resolution delay..." }
+
         @current_selector.after(0.05) do
-          unless connection.state == :closed ||
-                 # double emission check
-                 (connection.addresses && addresses.intersect?(connection.addresses))
+          # double emission check
+          unless connection.addresses && addresses.intersect?(connection.addresses)
             emit_resolved_connection(connection, addresses, early_resolve)
           end
         end
@@ -97,6 +101,8 @@ module HTTPX
       begin
         connection.addresses = addresses
 
+        return if connection.state == :closed
+
         emit(:resolve, connection)
       rescue StandardError => e
         if early_resolve
@@ -146,7 +152,7 @@ module HTTPX
     end
 
     def emit_connection_error(connection, error)
-      return connection.emit(:connect_error, error) if connection.connecting? && connection.callbacks_for?(:connect_error)
+      return connection.handle_connect_error(error) if connection.connecting?
 
       connection.emit(:error, error)
     end

data/lib/httpx/resolver/system.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require "forwardable"
 require "resolv"
 
 module HTTPX
   class Resolver::System < Resolver::Resolver
     using URIExtensions
-    extend Forwardable
 
     RESOLV_ERRORS = [Resolv::ResolvError,
                      Resolv::DNS::Requester::RequestError,
@@ -24,8 +22,6 @@ module HTTPX
 
     attr_reader :state
 
-    def_delegator :@connections, :empty?
-
     def initialize(options)
       super(nil, options)
       @resolver_options = @options.resolver_options
@@ -162,7 +158,9 @@ module HTTPX
 
       hostname = connection.peer.host
       scheme = connection.origin.scheme
-      log { "resolver: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}" } if connection.peer.non_ascii_hostname
+      log do
+        "resolver: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}"
+      end if connection.peer.non_ascii_hostname
 
       transition(:open)
 

data/lib/httpx/selector.rb

@@ -92,10 +92,6 @@ module HTTPX
       end
     end
 
-    def empty?
-      @selectables.empty?
-    end
-
     # deregisters +io+ from selectables.
     def deregister(io)
       @selectables.delete(io)

data/lib/httpx/session.rb

@@ -69,8 +69,6 @@ module HTTPX
       while (connection = @pool.pop_connection)
         next if connection.state == :closed
 
-        connection.current_session = self
-        connection.current_selector = selector
         select_connection(connection, selector)
       end
       begin
@@ -126,9 +124,15 @@ module HTTPX
     end
 
     def select_connection(connection, selector)
+      pin_connection(connection, selector)
       selector.register(connection)
     end
 
+    def pin_connection(connection, selector)
+      connection.current_session = self
+      connection.current_selector = selector
+    end
+
     alias_method :select_resolver, :select_connection
 
     def deselect_connection(connection, selector, cloned = false)
@@ -160,36 +164,8 @@ module HTTPX
       new_connection = connection.class.new(connection.origin, connection.options)
 
       new_connection.family = family
-      new_connection.current_session = self
-      new_connection.current_selector = selector
-
-      connection.once(:tcp_open) { new_connection.force_reset(true) }
-      connection.once(:connect_error) do |err|
-        if new_connection.connecting?
-          new_connection.merge(connection)
-          connection.emit(:cloned, new_connection)
-          connection.force_reset(true)
-        else
-          connection.__send__(:handle_error, err)
-        end
-      end
 
-      new_connection.once(:tcp_open) do |new_conn|
-        if new_conn != connection
-          new_conn.merge(connection)
-          connection.force_reset(true)
-        end
-      end
-      new_connection.once(:connect_error) do |err|
-        if connection.connecting?
-          # main connection has the requests
-          connection.merge(new_connection)
-          new_connection.emit(:cloned, connection)
-          new_connection.force_reset(true)
-        else
-          new_connection.__send__(:handle_error, err)
-        end
-      end
+      connection.sibling = new_connection
 
       do_init_connection(new_connection, selector)
       new_connection
@@ -203,14 +179,15 @@ module HTTPX
 
       connection = @pool.checkout_connection(request_uri, options)
 
-      connection.current_session = self
-      connection.current_selector = selector
-
       case connection.state
       when :idle
         do_init_connection(connection, selector)
       when :open
-        select_connection(connection, selector) if options.io
+        if options.io
+          select_connection(connection, selector)
+        else
+          pin_connection(connection, selector)
+        end
       when :closed
         connection.idling
         select_connection(connection, selector)
@@ -219,6 +196,8 @@ module HTTPX
           connection.idling
           select_connection(connection, selector)
         end
+      else
+        pin_connection(connection, selector)
       end
 
       connection
@@ -372,7 +351,6 @@ module HTTPX
         #    resolve a name (not the same as name being an IP, yet)
         # 2. when the connection is initialized with an external already open IO.
         #
-        connection.once(:connect_error, &connection.method(:handle_error))
         on_resolver_connection(connection, selector)
         return
       end
@@ -428,8 +406,6 @@ module HTTPX
         return false
       end
 
-      conn2.emit(:tcp_open, conn1)
-      conn1.merge(conn2)
       conn2.coalesced_connection = conn1
       select_connection(conn1, selector) if from_pool
       deselect_connection(conn2, selector)

data/lib/httpx/transcoder/body.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "forwardable"
+require "delegate"
 
 module HTTPX::Transcoder
   module Body
@@ -8,48 +8,32 @@ module HTTPX::Transcoder
 
     module_function
 
-    class Encoder
-      extend Forwardable
-
-      def_delegator :@raw, :to_s
-
-      def_delegator :@raw, :==
-
+    class Encoder < SimpleDelegator
       def initialize(body)
-        @raw = body
+        body = body.open(File::RDONLY, encoding: Encoding::BINARY) if Object.const_defined?(:Pathname) && body.is_a?(Pathname)
+        @body = body
+        super(body)
       end
 
       def bytesize
-        if @raw.respond_to?(:bytesize)
-          @raw.bytesize
-        elsif @raw.respond_to?(:to_ary)
-          @raw.sum(&:bytesize)
-        elsif @raw.respond_to?(:size)
-          @raw.size || Float::INFINITY
-        elsif @raw.respond_to?(:length)
-          @raw.length || Float::INFINITY
-        elsif @raw.respond_to?(:each)
+        if @body.respond_to?(:bytesize)
+          @body.bytesize
+        elsif @body.respond_to?(:to_ary)
+          @body.sum(&:bytesize)
+        elsif @body.respond_to?(:size)
+          @body.size || Float::INFINITY
+        elsif @body.respond_to?(:length)
+          @body.length || Float::INFINITY
+        elsif @body.respond_to?(:each)
           Float::INFINITY
         else
-          raise Error, "cannot determine size of body: #{@raw.inspect}"
+          raise Error, "cannot determine size of body: #{@body.inspect}"
         end
       end
 
       def content_type
         "application/octet-stream"
       end
-
-      private
-
-      def respond_to_missing?(meth, *args)
-        @raw.respond_to?(meth, *args) || super
-      end
-
-      def method_missing(meth, *args, &block)
-        return super unless @raw.respond_to?(meth)
-
-        @raw.__send__(meth, *args, &block)
-      end
     end
 
     def encode(body)

data/lib/httpx/transcoder/multipart/part.rb

@@ -19,7 +19,7 @@ module HTTPX
           value = value[:body]
         end
 
-        value = value.open(File::RDONLY) if Object.const_defined?(:Pathname) && value.is_a?(Pathname)
+        value = value.open(File::RDONLY, encoding: Encoding::BINARY) if Object.const_defined?(:Pathname) && value.is_a?(Pathname)
 
         if value.respond_to?(:path) && value.respond_to?(:read)
           # either a File, a Tempfile, or something else which has to quack like a file

data/lib/httpx/version.rb

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

data/lib/httpx.rb

@@ -61,6 +61,6 @@ require "httpx/session_extensions"
 
 # load integrations when possible
 
-require "httpx/adapters/datadog" if defined?(DDTrace) || defined?(Datadog)
+require "httpx/adapters/datadog" if defined?(DDTrace) || defined?(Datadog::Tracing)
 require "httpx/adapters/sentry" if defined?(Sentry)
 require "httpx/adapters/webmock" if defined?(WebMock)

data/sig/connection.rbs

@@ -26,11 +26,12 @@ module HTTPX
     attr_reader pending: Array[Request]
     attr_reader options: Options
     attr_reader ssl_session: OpenSSL::SSL::Session?
+    attr_reader sibling: instance?
     attr_writer current_selector: Selector?
-    attr_writer coalesced_connection: instance?
     attr_accessor current_session: Session?
     attr_accessor family: Integer?
 
+
     @window_size: Integer
     @read_buffer: Buffer
     @write_buffer: Buffer
@@ -45,6 +46,10 @@ module HTTPX
     @intervals: Array[Timers::Interval]
     @exhausted: bool
     @cloned: bool
+    @coalesced_connection: instance?
+    @sibling: instance?
+    @main_sibling: bool
+
 
     def addresses: () -> Array[ipaddr]?
 
@@ -70,6 +75,8 @@ module HTTPX
 
     def connecting?: () -> bool
 
+    def io_connected?: () -> bool
+
     def inflight?: () -> boolish
 
     def interests: () -> io_interests?
@@ -98,6 +105,12 @@ module HTTPX
 
     def handle_socket_timeout: (Numeric interval) -> void
 
+    def coalesced_connection=: (instance connection) -> void
+
+    def sibling=: (instance? connection) -> void
+
+    def handle_connect_error: (StandardError error) -> void
+
     private
 
     def initialize: (http_uri uri, Options options) -> void
@@ -134,6 +147,8 @@ module HTTPX
 
     def handle_error: (StandardError error, ?Request? request) -> void
 
+    def close_sibling: () -> void
+
     def purge_after_closed: () -> void
 
     def set_request_timeouts: (Request request) -> void

data/sig/request/body.rbs

@@ -31,12 +31,4 @@ module HTTPX
 
     def self.initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
   end
-
-  class ProcIO
-    @block: ^(String) -> void
-
-    def initialize: (^(String) -> void) -> untyped
-
-    def write: (String data) -> Integer
-  end
 end

data/sig/resolver/native.rbs

@@ -64,6 +64,8 @@ module HTTPX
       def handle_error: (NativeResolveError | StandardError) -> void
 
       def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
+
+      def close_or_resolve: () -> void
     end
   end
 end

data/sig/session.rbs

@@ -25,6 +25,8 @@ module HTTPX
 
     def select_connection: (Connection connection, Selector selector) -> void
 
+    def pin_connection: (Resolver::Resolver | Connection connection, Selector selector) -> void
+
     def deselect_connection: (Connection connection, Selector selector, ?bool cloned) -> void
 
     def select_resolver: (Resolver::Native | Resolver::HTTPS resolver, Selector selector) -> void

data/sig/transcoder/body.rbs

@@ -4,9 +4,7 @@ module HTTPX
       class Error < HTTPX::Error
       end
 
-      class Encoder
-        extend Forwardable
-
+      class Encoder #  < SimpleDelegator
         @raw: Object & bodyIO
 
         def bytesize: () -> (Integer | Float)

data/sig/transcoder/utils/body_reader.rbs

@@ -7,7 +7,7 @@ module HTTPX
 
       def bytesize: () -> (Integer | Float)
 
-      def read: (?int? length, ?string outbuf) -> String?
+      def read: (?int? length, ?string? outbuf) -> String?
 
       def close: () -> void
     end

data/sig/transcoder/utils/deflater.rbs

@@ -14,7 +14,7 @@ module HTTPX
 
       def bytesize: () -> (Integer | Float)
 
-      def read: (?int? length, ?string outbuf) -> String?
+      def read: (?int? length, ?string? outbuf) -> String?
 
       def close: () -> void
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-18 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -150,6 +150,7 @@ extra_rdoc_files:
 - doc/release_notes/1_3_3.md
 - doc/release_notes/1_3_4.md
 - doc/release_notes/1_4_0.md
+- doc/release_notes/1_4_1.md
 files:
 - LICENSE.txt
 - README.md
@@ -271,6 +272,7 @@ files:
 - doc/release_notes/1_3_3.md
 - doc/release_notes/1_3_4.md
 - doc/release_notes/1_4_0.md
+- doc/release_notes/1_4_1.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb