httpx 1.7.2 → 1.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c67e4695d8ef368321f14a3c113daad0e49280413e3da42272644ad84fe6f622
-  data.tar.gz: 62bb1ab9d91ca69c9b1fa561051ffb0ed137afb53e0b40f71cfd477a84a78773
+  metadata.gz: b34abe93b42862837d9131524d6e9663a93474f70c65ac2a10946eb62c9aeb14
+  data.tar.gz: '0853b845878005ace796106f79b735d9d75e205b7ab28c03a3786b53233d6a4b'
 SHA512:
-  metadata.gz: 266576dae6b8ed604228b464281239b760df9682d27e9010b18ac7dbab4fb00f23115e5bcae1a0ecee6b191ee03a0eca758c37f8f0baee0e2ad9df5ca0c7eff6
-  data.tar.gz: e355df3c634811d0d8e08bcb10b661a4f486073e6ca808ca3af3585a4d014cd404c8d7a55e38d0d05419f205d9dc81a54fb5a17eab7e1716c38c160297963e0f
+  metadata.gz: 0be425ba5468990b31fb3fe04b97ee8c727cc1f16690decc2057314c3645e5baa21fae9b54585bc6e628410374dbfd9b8676df3aaed180b321a9b59cbbad2853
+  data.tar.gz: 3cbe9b0e2952c7d330bffe727f2b478f53152d431a306d48f5f41cb5033e9ba7fa2ddec9a319aed49f051c8e9e6e2d8e489ecccc83a6c622246ef6922c9bbecc

data/README.md

@@ -46,7 +46,9 @@ And that's the simplest one there is. But you can also do:
 HTTPX.post("http://example.com", form: { user: "john", password: "pass" })
 
 http = HTTPX.with(headers: { "x-my-name" => "joe" })
-http.patch("http://example.com/file", body: File.open("path/to/file")) # request body is streamed
+File.open("path/to/file") do |file|
+  http.patch("http://example.com/file", body: file) # request body is streamed
+end
 ```
 
 If you want to do some more things with the response, you can get an `HTTPX::Response`:

data/doc/release_notes/1_7_3.md

@@ -0,0 +1,29 @@
+# 1.7.3
+
+## Improvements
+
+### cookies plugin: Jar as CookieStore
+
+While previously an implementation detail, the cookie jar from a `:cookie` plugin-enabled session can now be manipulated by the end user:
+
+```ruby
+cookies_sess = HTTPX.plugin(:cookies)
+
+jar = cookies.make_jar
+
+sess = cookies_ses.with(cookies: jar)
+
+# perform requests using sess, get/set/delete cookies in jar
+```
+
+The jar API now closely follows the [Web Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore), by providing the same set of functions.
+
+Some API backwards compatibility is maintained, however since this was an internal implementation detail, this effort isn't meant to be thorough.
+
+## Bugfixes
+
+* `http-2`: clear buffered data chunks when receiving a `GOAWAY` stream frame; without this, the client kept sending the corresponding `DATA` frames, despite the peer server making it known that it wouldn't process it. While this is valid HTTP/2, this could increase the connection window until a point where it'd go over the max frame size. this issue was observed during large file uploads where the first request could fail and make the client renegotiate.
+* `webmock` adapter: fixed response body length accounting which was making `response.body.empty?` return true for responses with payload.
+* `:rate_limiter` plugin relies on an internal refactoring to be able to wait for the time suggested by the peer server instead of the potentially relying on custom user logic via own `:retry_after`.
+* `:fiber_concurrency`: fix wrong names for native/system resolver overrides.
+* connection: fix for race condition when closing the connection, where the state only transitions to `closed` after checking the connection back in to the pool, potentially corrupting it if another session meanwhile has picked it up and manipulated it.

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 datadog 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/doc/release_notes/1_7_5.md

@@ -0,0 +1,10 @@
+# 1.7.5
+
+## Improvements
+
+* `:tracing` plugin: make `Request#init_time` a UTC timestamp.
+
+## Bugfixes
+
+* fixed handling of conditional responses which was making a batch of concurrent requests being handled serially after they failed.
+* `datadog` adapter: use `Request#init_time` as the span start time, which will fix the bug where the span wasn't including the time it takes to open the connection (TCP/TLS handhshakes).

data/doc/release_notes/1_7_6.md

@@ -0,0 +1,24 @@
+# 1.7.6
+
+## Improvements
+
+* `datadog` adapter: support setting custom `peer.service`.
+* stopped doing `Thread.pass` after checking connections back into the pool. The goal of this was to allow threads potentially waiting on a connection for the same origin to have the opportunity to take it before the same thread could check the same connection out, thereby preventing starvation on limited pool sizes; this however backfired for the common case of unbounded pool sizes (the default), and was specially bad when used for multiple concurrent requests on multiple origins, where avoidable lag was introduced on the whole processing every time a connection was checked back in. Thereby, the initial problem needs to be solved at the mutex implementation of CRuby.
+* connection: after keep alive timeout expired, try writing `PING` frame to the socket as soon as it's emitted (previously, the frame was being buffered and the socket would be probed for readiness before writing it, whereas in most cases this is avoidable).
+
+
+## Bugfixes
+
+* reuse the same resolver instance when resolving multiple concurrent requests in the same option (it was previously instantiating different ones based on option heuristics, such as when requests had different `:origin`).
+* on successful early name resolution (from cache or hosts file, for example), check the resolver back to the pool (the object was being dereferenced).
+* http1 parser: turn buffer back into a string on reset, instead of preserving its current type (in cases where it was a chunked transfer decoder and connection was kept-alive, it was keeping it around and using it to parse the next request, which broke).
+* http1 parser: enable pipelining based on the max concurrent requests, which the connection may have had pre-set to 1 based on prior knowledge of origin or other heuristics.
+* http1 parser: when disabling pipelining, mark incomplete inlined requests as idle before sending them back to the pending queue.
+* http1 and http2 parser: remove references to requests escalating an error; in scenarios of connection reuse (such as when using the `:persistent` plugin), these requests could be, on a transition to idle state, resent even in the absence of an external session reference, causing avoidable overhead or contention leading to timeouts or errors.
+* connection: rescue and ignore exceptions when calling `OpenSSL::SSL::SSLSocket#close` or `Socket#close`.
+* connection: when sending multiple requests into an open HTTP/2 connection which keep alive may have expired, only a single (instead of multiple, as before) `PING` frame will be sent (in the prior state, only the first `PING` was being acknowledged, which made the connection accumulate unacknowledged ping payloads).
+* connection: on handling errors, preventing potential race condition by copying pending requests into a local var before calling `parser.handle_error` (this may trigger a callback which calls `#reset`, which may call `#disconnect`, which would check the connection back into the pool and make it available for another thread, which could change the state of the ivar containing pending requests).
+* connection: skip resetting a connection when idle and having pending requests; this may happen in situation where parsers may have reset-and-back-to-idle the connection to resend failed requests as protocol (such as in the case of failed HTTP/1 pipelinining requests where incomplete requests are to be resent to the connection once pipelining is disabled).
+* connection: raise request timeout errors for the request the connection is currently in, instead of the connection where it was initially sent on and set timeouts on; this happens in situations where the request may be retried and sent to a different connection, which forces the request to keep a reference to the connection it's currently in (and discard it when it no longer needs it to prevent it from being GC'ed).
+* `:auth` plugin: when used alongside the `:retries` plugin for multiple concurrent requests, it was calling the dynamic token generator block once for each request; fixed to call the block only once per retry window, so retrying requests will reuse the same.
+* `:retries` plugin: retry request immediately if `:retry_after` is negative (while the option is validated for numbers, it can't control proc-based calculation).

data/lib/httpx/adapters/datadog.rb

@@ -19,6 +19,7 @@ module Datadog::Tracing
         Datadog::Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE
       end
       TAG_PEER_HOSTNAME = Datadog::Tracing::Metadata::Ext::TAG_PEER_HOSTNAME
+      TAG_PEER_SERVICE = Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
 
       TAG_KIND = Datadog::Tracing::Metadata::Ext::TAG_KIND
       TAG_CLIENT = Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CLIENT
@@ -46,35 +47,25 @@ module Datadog::Tracing
 
           SPAN_REQUEST = "httpx.request"
 
-          # initializes tracing on the +request+.
-          def call(request)
-            return unless configuration(request).enabled
-
-            span = nil
+          def enabled?(request)
+            configuration(request).enabled
+          end
 
-            # 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 start(request)
+            request.datadog_span = initialize_span(request, request.init_time)
+          end
 
-              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
@@ -118,7 +109,9 @@ module Datadog::Tracing
             span.set_tag(TAG_PEER_HOSTNAME, uri.host)
 
             # Tag as an external peer service
-            # span.set_tag(TAG_PEER_SERVICE, span.service)
+            if (peer_service = config[:peer_service])
+              span.set_tag(TAG_PEER_SERVICE, peer_service)
+            end
 
             if config[:distributed_tracing]
               propagate_trace_http(
@@ -137,13 +130,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)
-          end
-
-          def now
-            ::Datadog::Core::Utils::Time.now.utc
+        rescue StandardError => e
+          Datadog.logger.error("error preparing span for http request: #{e}")
+          Datadog.logger.error(e.backtrace)
           end
 
           def configuration(request)
@@ -179,44 +168,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
 
@@ -250,6 +213,11 @@ module Datadog::Tracing
               o.env "DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE"
               o.default 1.0
             end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env "DD_TRACE_HTTPX_PEER_SERVICE"
+            end
           else
             option :enabled do |o|
               o.default { env_to_bool("DD_TRACE_HTTPX_ENABLED", true) }
@@ -265,6 +233,11 @@ module Datadog::Tracing
               o.default { env_to_float(%w[DD_TRACE_HTTPX_ANALYTICS_SAMPLE_RATE DD_HTTPX_ANALYTICS_SAMPLE_RATE], 1.0) }
               o.lazy
             end
+
+            option :peer_service do |o|
+              o.default { env_to_string("DD_TRACE_HTTPX_PEER_SERVICE", nil) }
+              o.lazy
+            end
           end
 
           if defined?(Datadog::Tracing::Contrib::SpanAttributeSchema)

data/lib/httpx/adapters/webmock.rb

@@ -82,6 +82,7 @@ module WebMock
 
         def mock!
           @mocked = true
+          @body.mock!
         end
 
         def mocked?
@@ -90,10 +91,8 @@ module WebMock
       end
 
       module ResponseBodyMethods
-        def decode_chunk(chunk)
-          return chunk if @response.mocked?
-
-          super
+        def mock!
+          @inflaters = nil
         end
       end
 

data/lib/httpx/altsvc.rb

@@ -10,6 +10,8 @@ module HTTPX
 
       H2_ALTSVC_SCHEMES = %w[https h2].freeze
 
+      ALTSVC_IGNORE_IVARS = %i[@ssl].freeze
+
       def send(request)
         request.headers["alt-used"] = @origin.authority if @parser && !@write_buffer.full? && match_altsvcs?(request.uri)
 
@@ -35,11 +37,11 @@ module HTTPX
       end
 
       def match_altsvc_options?(uri, options)
-        return @options == options unless @options.ssl.all? do |k, v|
+        return @options.connection_options_match?(options) unless @options.ssl.all? do |k, v|
           v == (k == :hostname ? uri.host : options.ssl[k])
         end
 
-        @options.options_equals?(options, Options::REQUEST_BODY_IVARS + %i[@ssl])
+        @options.connection_options_match?(options, ALTSVC_IGNORE_IVARS)
       end
 
       def altsvc_match?(uri, other_uri)

data/lib/httpx/connection/http1.rb

@@ -28,7 +28,8 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
-      @handshake_completed = false
+      @request = nil
+      @handshake_completed = @pipelining = false
     end
 
     def timeout
@@ -49,7 +50,14 @@ module HTTPX
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
-      @pending.unshift(*@requests)
+      reset_requests
+    end
+
+    def reset_requests
+      requests = @requests
+      requests.each { |r| r.transition(:idle) }
+      @pending.unshift(*requests)
+      @requests.clear
     end
 
     def close
@@ -85,7 +93,7 @@ module HTTPX
       return if @requests.include?(request)
 
       @requests << request
-      @pipelining = true if @requests.size > 1
+      @pipelining = @max_concurrent_requests > 1 && @requests.size > 1
     end
 
     def consume
@@ -140,15 +148,17 @@ module HTTPX
 
       return unless request
 
-      log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
-      log(level: 2, color: :green) { "-> #{log_redact_body(chunk.inspect)}" }
-      response = request.response
+      begin
+        log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
+        log(level: 2, color: :green) { "-> #{log_redact_body(chunk.inspect)}" }
+        response = request.response
 
-      response << chunk
-    rescue StandardError => e
-      error_response = ErrorResponse.new(request, e)
-      request.response = error_response
-      dispatch
+        response << chunk
+      rescue StandardError => e
+        error_response = ErrorResponse.new(request, e)
+        request.response = error_response
+        dispatch(request)
+      end
     end
 
     def on_complete
@@ -157,12 +167,10 @@ module HTTPX
       return unless request
 
       log(level: 2) { "parsing complete" }
-      dispatch
+      dispatch(request)
     end
 
-    def dispatch
-      request = @request
-
+    def dispatch(request)
       if request.expects?
         @parser.reset!
         return handle(request)
@@ -175,6 +183,7 @@ module HTTPX
 
       if @parser.upgrade?
         response << @parser.upgrade_data
+        @parser.reset!
         throw(:called)
       end
 
@@ -211,12 +220,12 @@ module HTTPX
       if @pipelining
         catch(:called) { disable }
       else
-        @requests.each do |req|
+        while (req = @requests.shift)
           next if request && request == req
 
           emit(:error, req, ex)
         end
-        @pending.each do |req|
+        while (req = @pending.shift)
           next if request && request == req
 
           emit(:error, req, ex)
@@ -280,7 +289,6 @@ module HTTPX
     end
 
     def disable_pipelining
-      return if @requests.empty?
       # do not disable pipelining if already set to 1 request at a time
       return if @max_concurrent_requests == 1
 

data/lib/httpx/connection/http2.rb

@@ -3,8 +3,6 @@
 require "securerandom"
 require "http/2"
 
-HTTP2::Connection.__send__(:public, :send_buffer) if HTTP2::VERSION < "1.1.1"
-
 module HTTPX
   class Connection::HTTP2
     include Callbacks
@@ -59,29 +57,37 @@ module HTTPX
 
         return if @buffer.empty?
 
+        # HTTP/2 GOAWAY frame buffered.
         return :w
       end
 
       unless @connection.state == :connected && @handshake_completed
+        # HTTP/2 in intermediate state or still completing initialization-
         return @buffer.empty? ? :r : :rw
       end
 
       unless @connection.send_buffer.empty?
+        # HTTP/2 connection is buffering data chunks and failing to emit DATA frames,
+        # most likely because the flow control window is exhausted.
         return :rw unless @buffer.empty?
 
         # waiting for WINDOW_UPDATE frames
         return :r
       end
 
+      # there are pending bufferable requests
       return :w if !@pending.empty? && can_buffer_more_requests?
 
+      # there are pending frames from the last run
       return :w unless @drains.empty?
 
       if @buffer.empty?
+        # skip if no more requests or pings to process
         return if @streams.empty? && @pings.empty?
 
         :r
       else
+        # buffered frames
         :w
       end
     end
@@ -140,7 +146,7 @@ module HTTPX
         settings_ex.set_backtrace(ex.backtrace)
         ex = settings_ex
       end
-      @streams.each_key do |req|
+      while (req, _ = @streams.shift)
         next if request && request == req
 
         emit(:error, req, ex)
@@ -163,6 +169,8 @@ module HTTPX
       @pings.any?
     end
 
+    def reset_requests; end
+
     private
 
     def can_buffer_more_requests?
@@ -215,9 +223,7 @@ module HTTPX
     def handle_stream(stream, request)
       request.on(:refuse, &method(:on_stream_refuse).curry(3)[stream, request])
       stream.on(:close, &method(:on_stream_close).curry(3)[stream, request])
-      stream.on(:half_close) do
-        log(level: 2) { "#{stream.id}: waiting for response..." }
-      end
+      stream.on(:half_close) { on_stream_half_close(stream, request) }
       stream.on(:altsvc, &method(:on_altsvc).curry(2)[request.origin])
       stream.on(:headers, &method(:on_stream_headers).curry(3)[stream, request])
       stream.on(:data, &method(:on_stream_data).curry(3)[stream, request])
@@ -302,7 +308,7 @@ module HTTPX
       end
 
       log(color: :yellow) do
-        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")
+        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{k == ":status" ? v : log_redact_headers(v)}" }.join("\n")
       end
       _, status = h.shift
       headers = request.options.headers_class.new(h)
@@ -331,6 +337,16 @@ module HTTPX
       stream.close
     end
 
+    def on_stream_half_close(stream, _request)
+      unless stream.send_buffer.empty?
+        stream.send_buffer.clear
+        stream.data("", end_stream: true)
+      end
+
+      # TODO: omit log line if response already here
+      log(level: 2) { "#{stream.id}: waiting for response..." }
+    end
+
     def on_stream_close(stream, request, error)
       return if error == :stream_closed && !@streams.key?(request)
 
@@ -391,10 +407,9 @@ module HTTPX
           ex = GoawayError.new(error)
           ex.set_backtrace(caller)
 
-          @pending.unshift(*@streams.keys)
+          handle_error(ex)
           teardown
 
-          handle_error(ex)
         end
       end
       return unless is_connection_closed && @streams.empty?
@@ -404,34 +419,39 @@ module HTTPX
 
     def on_frame_sent(frame)
       log(level: 2) { "#{frame[:stream]}: frame was sent!" }
-      log(level: 2, color: :blue) do
-        payload =
-          case frame[:type]
-          when :data
-            frame.merge(payload: frame[:payload].bytesize)
-          when :headers, :ping
-            frame.merge(payload: log_redact_headers(frame[:payload]))
-          else
-            frame
-          end
-        "#{frame[:stream]}: #{payload}"
-      end
+      log(level: 2, color: :blue) { "#{frame[:stream]}: #{frame_with_extra_info(frame)}" }
     end
 
     def on_frame_received(frame)
       log(level: 2) { "#{frame[:stream]}: frame was received!" }
-      log(level: 2, color: :magenta) do
-        payload =
-          case frame[:type]
-          when :data
-            frame.merge(payload: frame[:payload].bytesize)
-          when :headers, :ping
-            frame.merge(payload: log_redact_headers(frame[:payload]))
-          else
-            frame
-          end
-        "#{frame[:stream]}: #{payload}"
-      end
+      log(level: 2, color: :magenta) { "#{frame[:stream]}: #{frame_with_extra_info(frame)}" }
+    end
+
+    def frame_with_extra_info(frame)
+      case frame[:type]
+      when :data
+        frame.merge(payload: frame[:payload].bytesize)
+      when :headers, :ping
+        frame.merge(payload: log_redact_headers(frame[:payload]))
+      when :window_update
+        connection_or_stream = if (id = frame[:stream]).zero?
+          @connection
+        else
+          @streams.each_value.find { |s| s.id == id }
+        end
+        if connection_or_stream
+          frame.merge(
+            local_window: connection_or_stream.local_window,
+            remote_window: connection_or_stream.remote_window,
+            buffered_amount: connection_or_stream.buffered_amount,
+            stream_state: connection_or_stream.state,
+          )
+        else
+          frame
+        end
+      else
+        frame
+      end.merge(connection_state: @connection.state)
     end
 
     def on_altsvc(origin, frame)