httpx 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aff2acc77577cb1243c30a63766f404755131c2f1b19162b9b6ba13c49d61f8
-  data.tar.gz: 6297b0857edce0f5d93a0272c2b5e891257969c36cbf0c34c6a7ca6e4a5ced67
+  metadata.gz: 7d5abc65b9f6377dbcefbe9170c7c47ef3555b4286c2d9c5e6e521467a75d57e
+  data.tar.gz: 7dfac2d6aa4ed5ecba31479ec0750de9d310657c39e12efd57f62d1544d9d1b7
 SHA512:
-  metadata.gz: 94da91dd14a8318e8f0a0199214f97c008b927c7b8d9f602f045434bbd375b4446c767ed805e424d826c3dc48e90a8a0fded192858d32763c4c38033e0107cae
-  data.tar.gz: 657cefe9a977ca56dddda02bbdb07a94b4a8f158193e5f0d695c254bdbcafd95ffccd29641d38958d16468a81fd236f4d95ef4487c335cf7e079fb29b8d456ba
+  metadata.gz: 720fe0c6f0883d0755122ae8009da116f7b06b0f009b56480cf3f1f80ef998e4671d6f53ce039e6d52f502c596e22fa524d6292a3372c8bd3a7f88616f6aaffc
+  data.tar.gz: 75fdb8eee5568a3be2fdd19a4750b18166d2eb25749a0a1cde672b0deab76d1e64c8d573665488b7d2db99d4de73f387583a75ad5a957be9529dfef4b36f11ac

data/doc/release_notes/1_2_3.md

@@ -0,0 +1,16 @@
+# 1.2.3
+
+## Improvements
+
+* `:retries` plugin: allow `:max_retries` set to 0 (allows for a soft disable of retries when using the faraday adapter).
+
+## Bugfixes
+
+* `:oauth` plugin: fix for default auth method being ignored when setting grant type and scope as options only.
+*  ensure happy eyeballs-initiated cloned connections also set session callbacks (caused issues when server would respond with a 421 response, an event requiring a valid internal callback).
+*  native resolver cleanly transitions from tcp to udp after truncated DNS query (causing issues on follow-up CNAME resolution).
+* elapsing timeouts now guard against mutation of callbacks while looping (prevents skipping callbacks in situations where a previous one would remove itself from the collection).
+
+## Chore
+
+* datadog adapter: do not call `.lazy` on options (avoids deprecation warning, to be removed in ddtrace 2.0)

data/doc/release_notes/1_2_4.md

@@ -0,0 +1,8 @@
+# 1.2.4
+
+## Bugfixes
+
+* fixed issue related to inability to buffer payload to error responses (which may happen on certain error handling situations).
+* fixed recovery from a lost persistent connection leaving process due to ping being sent while still marked as inactive.
+* fixed datadog integration, which was not generating new spans on retried requests (when `:retries` plugin is enabled).
+* fixed splitting strings into key value pairs in cases where the value would contain a "=", such as in certain base64 payloads.

data/lib/httpx/adapters/datadog.rb

@@ -7,6 +7,8 @@ require "datadog/tracing/contrib/patcher"
 module Datadog::Tracing
   module Contrib
     module HTTPX
+      DATADOG_VERSION = defined?(::DDTrace) ? ::DDTrace::VERSION : ::Datadog::VERSION
+
       METADATA_MODULE = Datadog::Tracing::Metadata
 
       TYPE_OUTBOUND = Datadog::Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -22,9 +24,10 @@ module Datadog::Tracing
 
       # HTTPX Datadog Plugin
       #
-      # Enables tracing for httpx requests. A span will be created for each individual requests,
-      # and it'll trace since the moment it is fed to the connection, until the moment the response is
-      # fed back to the session.
+      # 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.
       #
       module Plugin
         class RequestTracer
@@ -32,82 +35,174 @@ module Datadog::Tracing
 
           SPAN_REQUEST = "httpx.request"
 
+          # initializes the tracer object on the +request+.
           def initialize(request)
             @request = request
+            @start_time = 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 }
+            # 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
 
-          def call
-            return unless Datadog::Tracing.enabled?
+          # sets up the span start time, while preparing the on response callback.
+          def call(*args)
+            return if @start_time
+
+            start(*args)
+
+            @request.once(:response, &method(:finish))
+          end
+
+          private
+
+          # 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
+
+          # resets the start time for already finished request transactions.
+          def reset
+            return unless @start_time
 
-            @request.on(:response, &method(:finish))
+            start
+          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
+
+            if response.is_a?(::HTTPX::ErrorResponse)
+              span.set_error(response.error)
+            else
+              span.set_tag(TAG_STATUS_CODE, response.status.to_s)
+
+              span.set_error(::HTTPX::HTTPError.new(response)) if response.status >= 400 && response.status <= 599
+            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
 
-            @span = Datadog::Tracing.trace(
-              SPAN_REQUEST,
-              service: service_name(@request.uri.host, configuration, Datadog.configuration_for(self)),
-              span_type: TYPE_OUTBOUND
-            )
+            span = create_span(@request)
 
-            @span.resource = verb
+            span.resource = verb
 
             # Add additional request specific tags to the span.
 
-            @span.set_tag(TAG_URL, @request.path)
-            @span.set_tag(TAG_METHOD, verb)
+            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_HOST, uri.host)
+            span.set_tag(TAG_TARGET_PORT, uri.port.to_s)
 
             # Tag as an external peer service
-            @span.set_tag(TAG_PEER_SERVICE, @span.service)
+            span.set_tag(TAG_PEER_SERVICE, span.service)
 
-            Datadog::Tracing::Propagation::HTTP.inject!(Datadog::Tracing.active_trace,
-                                                        @request.headers) if @configuration[:distributed_tracing]
+            if configuration[:distributed_tracing]
+              propagate_trace_http(
+                Datadog::Tracing.active_trace.to_digest,
+                @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?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
             end
+
+            span
           rescue StandardError => e
             Datadog.logger.error("error preparing span for http request: #{e}")
             Datadog.logger.error(e.backtrace)
           end
 
-          def finish(response)
-            return unless @span
+          def now
+            ::Datadog::Core::Utils::Time.now.utc
+          end
 
-            if response.is_a?(::HTTPX::ErrorResponse)
-              @span.set_error(response.error)
-            else
-              @span.set_tag(TAG_STATUS_CODE, response.status.to_s)
+          def configuration
+            @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
+          end
 
-              @span.set_error(::HTTPX::HTTPError.new(response)) if response.status >= 400 && response.status <= 599
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("2.0.0.beta1")
+            def propagate_trace_http(digest, headers)
+              Datadog::Tracing::Contrib::HTTP.inject(digest, headers)
             end
 
-            @span.finish
-          end
-
-          private
+            def create_span(request)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration, Datadog.configuration_for(self)),
+                type: TYPE_OUTBOUND,
+                start_time: @start_time
+              )
+            end
+          else
+            def propagate_trace_http(digest, headers)
+              Datadog::Tracing::Propagation::HTTP.inject!(digest, headers)
+            end
 
-          def configuration
-            @configuration ||= Datadog.configuration.tracing[:httpx, @request.uri.host]
+            def create_span(request)
+              Datadog::Tracing.trace(
+                SPAN_REQUEST,
+                service: service_name(request.uri.host, configuration, Datadog.configuration_for(self)),
+                span_type: TYPE_OUTBOUND,
+                start_time: @start_time
+              )
+            end
           end
         end
 
         module RequestMethods
-          def __datadog_enable_trace!
-            return if @__datadog_enable_trace
+          # intercepts request initialization to inject the tracing logic.
+          def initialize(*)
+            super
+
+            return unless Datadog::Tracing.enabled?
 
-            RequestTracer.new(self).call
-            @__datadog_enable_trace = true
+            RequestTracer.new(self)
           end
         end
 
         module ConnectionMethods
-          def send(request)
-            request.__datadog_enable_trace!
+          attr_reader :init_time
+
+          def initialize(*)
+            super
+
+            @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)
+            return super unless Datadog::Tracing.enabled?
+
+            return super unless error.respond_to?(:connection)
+
+            @pending.each do |request|
+              RequestTracer.new(request).call(error.connection.init_time)
+            end
 
             super
           end
@@ -126,7 +221,7 @@ module Datadog::Tracing
           option :distributed_tracing, default: true
           option :split_by_domain, default: false
 
-          if Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
             option :enabled do |o|
               o.type :bool
               o.env "DD_TRACE_HTTPX_ENABLED"
@@ -169,25 +264,25 @@ module Datadog::Tracing
                   "httpx"
                 )
               end
-              o.lazy
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
             end
           else
             option :service_name do |o|
               o.default do
                 ENV.fetch("DD_TRACE_HTTPX_SERVICE_NAME", "httpx")
               end
-              o.lazy
+              o.lazy unless Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
             end
           end
 
           option :distributed_tracing, default: true
 
-          if Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.15.0")
+          if Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.15.0")
             option :error_handler do |o|
               o.type :proc
               o.default_proc(&DEFAULT_ERROR_HANDLER)
             end
-          elsif Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+          elsif Gem::Version.new(DATADOG_VERSION::STRING) >= Gem::Version.new("1.13.0")
             option :error_handler do |o|
               o.type :proc
               o.experimental_default_proc(&DEFAULT_ERROR_HANDLER)

data/lib/httpx/altsvc.rb

@@ -131,9 +131,9 @@ module HTTPX
           scanner.skip(/;/)
           break if scanner.eos? || scanner.scan(/ *, */)
         end
-        alt_params = Hash[alt_params.map { |field| field.split("=") }]
+        alt_params = Hash[alt_params.map { |field| field.split("=", 2) }]
 
-        alt_proto, alt_authority = alt_service.split("=")
+        alt_proto, alt_authority = alt_service.split("=", 2)
         alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
         return unless alt_origin
 

data/lib/httpx/connection/http1.rb

@@ -245,7 +245,7 @@ module HTTPX
         return unless keep_alive
 
         parameters = Hash[keep_alive.split(/ *, */).map do |pair|
-          pair.split(/ *= */)
+          pair.split(/ *= */, 2)
         end]
         @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
 

data/lib/httpx/connection.rb

@@ -241,8 +241,8 @@ module HTTPX
           # for such cases, we want to ping for availability before deciding to shovel requests.
           log(level: 3) { "keep alive timeout expired, pinging connection..." }
           @pending << request
-          parser.ping
           transition(:active) if @state == :inactive
+          parser.ping
           return
         end
 

data/lib/httpx/plugins/auth/digest.rb

@@ -30,7 +30,8 @@ module HTTPX
           auth_info = authenticate[/^(\w+) (.*)/, 2]
 
           params = auth_info.split(/ *, */)
-                            .to_h { |val| val.split("=") }.transform_values { |v| v.delete("\"") }
+                            .to_h { |val| val.split("=", 2) }
+                            .transform_values { |v| v.delete("\"") }
           nonce = params["nonce"]
           nc = next_nonce
 

data/lib/httpx/plugins/aws_sigv4.rb

@@ -197,8 +197,8 @@ module HTTPX
           params.each.with_index.sort do |a, b|
             a, a_offset = a
             b, b_offset = b
-            a_name, a_value = a.split("=")
-            b_name, b_value = b.split("=")
+            a_name, a_value = a.split("=", 2)
+            b_name, b_value = b.split("=", 2)
             if a_name == b_name
               if a_value == b_value
                 a_offset <=> b_offset

data/lib/httpx/plugins/oauth.rb

@@ -16,7 +16,7 @@ module HTTPX
       SUPPORTED_AUTH_METHODS = %w[client_secret_basic client_secret_post].freeze
 
       class OAuthSession
-        attr_reader :token_endpoint_auth_method, :grant_type, :client_id, :client_secret, :access_token, :refresh_token, :scope
+        attr_reader :grant_type, :client_id, :client_secret, :access_token, :refresh_token, :scope
 
         def initialize(
           issuer:,
@@ -28,7 +28,7 @@ module HTTPX
           token_endpoint: nil,
           response_type: nil,
           grant_type: nil,
-          token_endpoint_auth_method: "client_secret_basic"
+          token_endpoint_auth_method: nil
         )
           @issuer = URI(issuer)
           @client_id = client_id
@@ -43,10 +43,10 @@ module HTTPX
           end
           @access_token = access_token
           @refresh_token = refresh_token
-          @token_endpoint_auth_method = String(token_endpoint_auth_method)
+          @token_endpoint_auth_method = String(token_endpoint_auth_method) if token_endpoint_auth_method
           @grant_type = grant_type || (@refresh_token ? "refresh_token" : "client_credentials")
 
-          unless SUPPORTED_AUTH_METHODS.include?(@token_endpoint_auth_method)
+          unless @token_endpoint_auth_method.nil? || SUPPORTED_AUTH_METHODS.include?(@token_endpoint_auth_method)
             raise Error, "#{@token_endpoint_auth_method} is not a supported auth method"
           end
 
@@ -59,8 +59,12 @@ module HTTPX
           @token_endpoint || "#{@issuer}/token"
         end
 
+        def token_endpoint_auth_method
+          @token_endpoint_auth_method || "client_secret_basic"
+        end
+
         def load(http)
-          return if @token_endpoint_auth_method && @grant_type && @scope
+          return if @grant_type && @scope
 
           metadata = http.get("#{@issuer}/.well-known/oauth-authorization-server").raise_for_status.json
 
@@ -123,11 +127,11 @@ module HTTPX
 
           # auth
           case oauth_session.token_endpoint_auth_method
-          when "client_secret_basic"
-            headers["authorization"] = Authentication::Basic.new(oauth_session.client_id, oauth_session.client_secret).authenticate
           when "client_secret_post"
             form_post["client_id"] = oauth_session.client_id
             form_post["client_secret"] = oauth_session.client_secret
+          when "client_secret_basic"
+            headers["authorization"] = Authentication::Basic.new(oauth_session.client_id, oauth_session.client_secret).authenticate
           end
 
           case grant_type

data/lib/httpx/plugins/retries.rb

@@ -58,7 +58,7 @@ module HTTPX
 
         def option_max_retries(value)
           num = Integer(value)
-          raise TypeError, ":max_retries must be positive" unless num.positive?
+          raise TypeError, ":max_retries must be positive" unless num >= 0
 
           num
         end

data/lib/httpx/pool.rb

@@ -179,6 +179,7 @@ module HTTPX
       connection.once(:connect_error) do |err|
         if new_connection.connecting?
           new_connection.merge(connection)
+          connection.emit(:cloned, new_connection)
           connection.force_reset
         else
           connection.__send__(:handle_error, err)
@@ -195,6 +196,7 @@ module HTTPX
         if connection.connecting?
           # main connection has the requests
           connection.merge(new_connection)
+          new_connection.emit(:cloned, connection)
           new_connection.force_reset
         else
           new_connection.__send__(:handle_error, err)

data/lib/httpx/resolver/native.rb

@@ -187,10 +187,10 @@ module HTTPX
             next unless @large_packet.full?
 
             parse(@large_packet.to_s)
-
             @socket_type = @resolver_options.fetch(:socket_type, :udp)
             @large_packet = nil
-            transition(:closed)
+            transition(:idle)
+            transition(:open)
             return
           else
             size = @read_buffer[0, 2].unpack1("n")

data/lib/httpx/response.rb

@@ -7,10 +7,18 @@ require "fileutils"
 require "forwardable"
 
 module HTTPX
-  # Defines a HTTP response is handled internally, with a few properties exposed as attributes,
-  # implements (indirectly, via the +body+) the IO write protocol to internally buffer payloads,
-  # implements the IO reader protocol in order for users to buffer/stream it, acts as an enumerable
+  # Defines a HTTP response is handled internally, with a few properties exposed as attributes.
+  #
+  # It delegates the following methods to the corresponding HTTPX::Request:
+  #
+  # * HTTPX::Request#uri
+  # * HTTPX::Request#peer_address
+  #
+  # It implements (indirectly, via the +body+) the IO write protocol to internally buffer payloads.
+  #
+  # It implements the IO reader protocol in order for users to buffer/stream it, acts as an enumerable
   # (of payload chunks).
+  #
   class Response
     extend Forwardable
     include Callbacks
@@ -21,7 +29,13 @@ module HTTPX
     # an HTTPX::Headers object containing the response HTTP headers.
     attr_reader :headers
 
-    # a HTTPX::Response::Body object wrapping the response body.
+    # a HTTPX::Response::Body object wrapping the response body. The following methods are delegated to it:
+    #
+    # * HTTPX::Response::Body#to_s
+    # * HTTPX::Response::Body#to_str
+    # * HTTPX::Response::Body#read
+    # * HTTPX::Response::Body#copy_to
+    # * HTTPX::Response::Body#close
     attr_reader  :body
 
     # The HTTP protocol version used to fetch the response.
@@ -260,6 +274,11 @@ module HTTPX
     def raise_for_status
       raise @error
     end
+
+    # buffers lost chunks to error response
+    def <<(data)
+      @response << data
+    end
   end
 end
 

data/lib/httpx/session.rb

@@ -138,7 +138,7 @@ module HTTPX
 
     # sets the callbacks on the +connection+ required to process certain specific
     # connection lifecycle events which deal with request rerouting.
-    def set_connection_callbacks(connection, connections, options)
+    def set_connection_callbacks(connection, connections, options, cloned: false)
       connection.only(:misdirected) do |misdirected_request|
         other_connection = connection.create_idle(ssl: { alpn_protocols: %w[http/1.1] })
         other_connection.merge(connection)
@@ -154,6 +154,10 @@ module HTTPX
         other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)
         connections << other_connection if other_connection
       end
+      connection.only(:cloned) do |cloned_conn|
+        set_connection_callbacks(cloned_conn, connections, options, cloned: true)
+        connections << cloned_conn
+      end unless cloned
     end
 
     # returns an HTTPX::Connection for the negotiated Alternative Service (or none).

data/lib/httpx/timers.rb

@@ -97,7 +97,10 @@ module HTTPX
       def elapse(elapsed)
         @interval -= elapsed
 
-        @callbacks.each(&:call) if @interval <= 0
+        if @interval <= 0
+          cb = @callbacks.dup
+          cb.each(&:call)
+        end
 
         @interval
       end

data/lib/httpx/version.rb

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

data/sig/plugins/oauth.rbs

@@ -15,8 +15,6 @@ module HTTPX
       SUPPORTED_AUTH_METHODS: ::Array[token_auth_method]
 
       class OAuthSession
-        attr_reader token_endpoint_auth_method: token_auth_method
-
         attr_reader grant_type: grant_type
 
         attr_reader client_id: String
@@ -33,6 +31,8 @@ module HTTPX
 
         def token_endpoint: () -> String
 
+        def token_endpoint_auth_method: () -> token_auth_method
+
         def load: (Session http) -> void
 
         def merge: (instance | Hash[untyped, untyped] other) -> instance

data/sig/response.rbs

@@ -70,6 +70,7 @@ module HTTPX
 
   class ErrorResponse
     include _Response
+    include _Reader
     include Loggable
     extend Forwardable
 

data/sig/session.rbs

@@ -31,7 +31,7 @@ module HTTPX
 
     def send_request: (Request request, Array[Connection] connections, ?Options options) -> void
 
-    def set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options) -> void
+    def set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options, ?cloned: bool) -> void
 
     def set_request_callbacks: (Request request) -> void
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-02 00:00:00.000000000 Z
+date: 2024-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -140,6 +140,8 @@ extra_rdoc_files:
 - doc/release_notes/1_2_0.md
 - doc/release_notes/1_2_1.md
 - doc/release_notes/1_2_2.md
+- doc/release_notes/1_2_3.md
+- doc/release_notes/1_2_4.md
 files:
 - LICENSE.txt
 - README.md
@@ -251,6 +253,8 @@ files:
 - doc/release_notes/1_2_0.md
 - doc/release_notes/1_2_1.md
 - doc/release_notes/1_2_2.md
+- doc/release_notes/1_2_3.md
+- doc/release_notes/1_2_4.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb