httpx 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8803154870d8bd0f45f67ce543072fcc42d789400ca0c9251d3ea99f5f214562
-  data.tar.gz: 87024f70caa91f93711b6a185a8e3dc7b8987d695472abd13a5a4cb92243d37c
+  metadata.gz: 7d5abc65b9f6377dbcefbe9170c7c47ef3555b4286c2d9c5e6e521467a75d57e
+  data.tar.gz: 7dfac2d6aa4ed5ecba31479ec0750de9d310657c39e12efd57f62d1544d9d1b7
 SHA512:
-  metadata.gz: ba28ac993c5b17d4d13db24240214a40cfbae5eac5fad40e6420e42725356a289ee33fcb02492bc382d2c26ce93a0696acf7f5f8d64ddf430136ee829f717b70
-  data.tar.gz: 93c174e3d210681f1c76127f7a3a69adf43d8a5b3c31432ae0b6e08abd96ca7d189399081efeed710f8c43566e3290931d04b2c38df7de0251508933b2fca129
+  metadata.gz: 720fe0c6f0883d0755122ae8009da116f7b06b0f009b56480cf3f1f80ef998e4671d6f53ce039e6d52f502c596e22fa524d6292a3372c8bd3a7f88616f6aaffc
+  data.tar.gz: 75fdb8eee5568a3be2fdd19a4750b18166d2eb25749a0a1cde672b0deab76d1e64c8d573665488b7d2db99d4de73f387583a75ad5a957be9529dfef4b36f11ac

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
+
+            start
+          end
 
-            @request.on(:response, &method(:finish))
+          # 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
 
-            RequestTracer.new(self).call
-            @__datadog_enable_trace = true
+            return unless Datadog::Tracing.enabled?
+
+            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 unless Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+              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 unless Gem::Version.new(DDTrace::VERSION::STRING) >= Gem::Version.new("1.13.0")
+              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/response.rb

@@ -274,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/version.rb

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

data/sig/response.rbs

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-04 00:00:00.000000000 Z
+date: 2024-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -141,6 +141,7 @@ extra_rdoc_files:
 - 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
@@ -253,6 +254,7 @@ files:
 - 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