httpx 1.9.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e272ec707fd07e29993d6f5eff50f84f40ad4da61503552f1de2698a8b56b72b
-  data.tar.gz: 10ebe441bd62cc1fec49c3caedb7a564dd998d2dd49d0740b3224f583f23e506
+  metadata.gz: 8eaea3d273dcba77ecae2abaf1979fa7ebbfddadf5c8f67b71636aac594b12e6
+  data.tar.gz: d4e50760994c7dff6d7ae963427f721ce349add9455055e01fc7074b2a9350ed
 SHA512:
-  metadata.gz: 860445bf67dc3bb69f9724d1dcc13f5a7c21a936420addd0923aa4d955be929afd95b87fb032f5a226d245d65b4e07654b6df431992e755341583a5f0e5c26f9
-  data.tar.gz: 4f11cd526c5099fa92d47fbd6b08a4366af6a01f4075f3df96f861cf7f3ce33e17a34e69f436b453e51d8afa07535b2bc62c04e1c1f260942782b0f432cc7383
+  metadata.gz: ae04971cb261d34dd72b1cd724e66e57321909e087b122357ab4506dfb4955603fc3c2ea54c9e34e9e9dcf5484aa347c89ad8c72a9fe94db26706c6850fc5442
+  data.tar.gz: a1e5ed666d7419b80da97449150ee67c95d2b1b9855e77060fff123aeaeaf268fb4caafde3242c9421d9cd042e5df14a088ecad30c837449a9fdee2b3376f6cb

data/doc/release_notes/1_8_1.md

@@ -14,7 +14,7 @@
 ## Bugfixes
 
 * `:auth` plugin: handle edge case where `:auth_header_expires_at` returns no value.
-* `:digest_auth` plugin: do not retry if there was an issue building building the authorization header after the probe.
+* `:digest_auth` plugin: do not retry if there was an issue building the authorization header after the probe.
 * `webmock` adapter: prevent mocked requests from opening a connection to the peer server that will not be used.
 * clear and cancel request timers on completion or reset, ensuring that they won't be retained way past the point where the request is gone.
 * connection: cancel and discard ping timer before closing (removes timer reference)

data/doc/release_notes/1_8_2.md

@@ -11,7 +11,7 @@ session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown opt
 
 * Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
 * Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
-* Improve correctness of calling `#dup` on requests and connections.
+* Improve the correctness of calling `#dup` on requests and connections.
 
 ## Bugfixes
 
@@ -21,10 +21,10 @@ session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown opt
 * `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
 * `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
 * `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
-* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
-* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubbles up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason being, making it more accurate.
 * webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
 * native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
 * fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
 * connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
-* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.
+* do not set a ping timer for HTTP/1.1 on keep-alive flow, as there's no ping and the connection is reestablished.

data/doc/release_notes/1_8_3.md

@@ -2,8 +2,6 @@
 
 ## Bugfixes
 
-options print a  warning instead of raising an error on unknown option
-
-the approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
-
-the format of options messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.
+* options print a  warning instead of raising an error on unknown option
+  * The approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
+* The format of option messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.

data/doc/release_notes/1_8_4.md

@@ -10,4 +10,4 @@
 * `:retries` plugin: resend requests which were piped to a closed connection internally.
 * `:proxy` plugin: fix issue related with reconnecting inactive connections shut down by the peer, when used with the `:persistent` plugin, where the CONNECT request wasn't being sent to establish the tunnel.
 * fixed compatibility issue starting with the `json` gem 3.0.0, when calling `HTTPX::Response#json`.
-* avoid bookkepping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).
+* avoid bookkeeping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).

data/doc/release_notes/1_9_0.md

@@ -4,7 +4,7 @@
 
 ### `:hedging` plugin
 
-The `:hedging` implements a strategy called "request hedging", whereby a request is sent a request two times, over different connections, and picking up whichever arrives first.
+The `:hedging` plugin implements a strategy called "request hedging", whereby a request is sent two times, over different connections, and picking up whichever arrives first.
 
 ```ruby
 http = HTTP.plugin(:hedging)
@@ -12,7 +12,7 @@ http.get("http://www.example.com")
 # sent two times, only the fastest one comes back...
 ```
 
-ou can read more about it in https://gitlab.com/os85/httpx/wikis/Hedging .
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Hedging .
 
 ### `:proxy/http` plugin: new options `:proxy_headers` and `:enable_proxy_tunnel`
 
@@ -20,7 +20,7 @@ The `:proxy/http` plugin (which gets automatically loaded by the `:proxy` plugin
 
 #### `:proxy_headers`
 
-Can be passed a separate set of HTTP headers, which are going to be sent to the proxy when establishing the the CONNECT proxy tunnel.
+Can be passed a separate set of HTTP headers, which are going to be sent to the proxy when establishing the CONNECT proxy tunnel.
 
 ```ruby
 http = HTTPX.plugin(:proxy).with(proxy_headers: { "x-proxy-1" => "foo" }, headers: { "x-header-1" => "bar" }).get("https://example.com")
@@ -48,10 +48,10 @@ When set to `true`, it forces the establishment of a CONNECT proxy tunnel before
 
 ## Bugfixes
 
-* `:auth` plugin: fixed clause inverted check, which caused caused a new token to always be generated on retry.
-* `:auth` plugin: take auth_header_expires_at into account when deciding to regenerate on retry (token may have been expired by the time the request will be retried).
+* `:auth` plugin: fixed clause inverted check, which caused a new token to always be generated on retry.
+* `:auth` plugin: take auth_header_expires_at into account when deciding to regenerate on retry (token may have expired by the time the request will be retried).
 * `:tracing` plugin: fixed request initial time calculation in order to take into account the time to wait for a PING correctly.
-* `:tracing` plugin: fixed request initial time calculation for pending requests which were waiting for the connect phase and errored meanwhie.
+* `:tracing` plugin: fixed request initial time calculation for pending requests which were waiting for the connect phase and errored meanwhile.
 * `:proxy/http` plugin: `:headers` will not be sent anymore to the proxy when establishing the CONNECT proxy tunnel.
 * socket connect timeout bookkeeping is fixed, where in a multi request scenario, connect timeout errors shall not be raised too early if an error happens before the remainder of connections elapses.
 * `:proxy` plugin: allow proxy params to be frozen, which also fixes an issue where proxies identified as unhealthy by a previous request, would still be retried on for different hostnames.
@@ -72,4 +72,4 @@ When set to `true`, it forces the establishment of a CONNECT proxy tunnel before
 
 ## Chore
 
-* Emit warning message whenever connection is deactivated with pending requests; the message contains internal state which should help debug it.
+* Emit a warning message whenever the connection is deactivated with pending requests; the message contains an internal state which should help debug it.

data/doc/release_notes/1_9_1.md

@@ -0,0 +1,32 @@
+# 1.9.1
+
+# Improvements
+
+* `:connect_timeout` will be split across the IP addresses available for the hostname. The connection phase will then loop on the list, and on each connect timeout, the next IP will tried; the connect timeout error will then only be raised if no healthy connections could be established to any of the IPs. This is the same heuristic used by curl v7.
+* Connections and parsers share the same pending requests queue: before, each had their own, and requests could fly across them depending on the several edge cases, thereby making it needlessly complex and wasteful. Also, when moving requests is necessary, they can short-circuit more efficiently.
+* Handled quoted charset property when parsing the "content-type" header in the response.
+* http1: Support peer server keep alive timeout (exposed via a response header like "Keep-Alive: timeout=10"), which overrides the client (or the default) `:keep_alive_timeout` setting.
+* http2: during the consumption loop, handle more pending requests when the window allows it.
+* several improvements on connection read/write consumption handling which save a few socket read/write syscalls.
+
+
+## Bugfixes
+
+* fix the json decoding integration with `oj`, which was using the `Oj.load` function in an unsafe manner, which `oj` documents. It now uses the `:strict` mode by default.
+* when doing Happy Eyeballs v2, do not accidentally coalesce sibling connections.
+* on session termination, ensure that idle connections are closed, something which may happen when an `alt-svc` response header creates a new connection, but no subsequent requests are sent its way.
+* fix race condition when terminating a selector, where its connections were checked on its state after termination; because terminated connections get checked back into the pool, they may be checked out before the state check happens. This fixes it by checking its current selector against itself.
+* ensure that the selector only calls the error handling once for the same connection.
+* request timeouts are now only set when the parser accepts them, and guaranteed only once.
+* when an operation timeout occurs, do not raise it on connections for which one wasn't set.
+* native resolver: fix DNS query retry handling due to a confusion about using `Enumerable.first` and `Enumerable.find`, and the former silently ignoring passed blocks.
+* native resolver: discard received answers for DNS queries which have since been dropped due to a timeout.
+* native resolver: try out the next nameserver in case the prior was unreachable.
+* http-2: keep processing unfinished streams when receiving a GOAWAY with a last stream id pointing to streams that haven't been finished.
+* `faraday` adapter: always load the `OnData` plugin, as a streaming request (which uses the `.on_data` Faraday API) may be preceded by a non-streaming request to fetch metadata (a pattern observed when using the google cloud storage ruby SDK).
+* `ntml` and `ntlmv2` plugins: when used to send multiple requests, should return an array of responses.
+* `oauth` plugin: fix wrong method call.
+* `cache` plugin: skip cache flow for error responses.
+* `proxy` plugin: make the class used for the CONNECT proxy request inherit all functionality from other loaded plugins.
+* `fiber_concurrency`: fixed some corner cases where the connection could loop indefinitely or become corrupt.
+* `tracing`: fixing request start time bookkeeping.

data/lib/httpx/adapters/faraday.rb

@@ -33,7 +33,7 @@ module Faraday
 
             @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
           end
-          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+          @connection = @connection.plugin(OnDataPlugin)
 
           @connection = @config_block.call(@connection) || @connection if @config_block
           @connection

data/lib/httpx/adapters/webmock.rb

@@ -20,11 +20,21 @@ module WebMock
           WebMock::RequestSignature.new(
             request.verb.downcase.to_sym,
             uri.to_s,
-            body: request.body.to_s,
+            body: build_webmock_request_body(request),
             headers: request.headers.to_h
           )
         end
 
+        def build_webmock_request_body(request)
+          body = request.body
+
+          return body.to_s unless body.respond_to?(:read)
+
+          body.read.to_s.tap do
+            body.rewind
+          end
+        end
+
         def build_webmock_response(_request, response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [response.status, HTTP_REASONS[response.status]]
@@ -61,6 +71,9 @@ module WebMock
         def do_init_connection(connection, selector)
           super
 
+          # skip for connections generated by HEv2 logic.
+          return if connection.family
+
           connection.once(:unmock_connection) do
             next unless connection.current_session == self
 

data/lib/httpx/connection/http1.rb

@@ -20,14 +20,14 @@ module HTTPX
 
     attr_accessor :max_concurrent_requests
 
-    def initialize(buffer, options)
+    def initialize(buffer, pending, options)
       @options = options
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
       @max_requests = @options.max_requests
       @parser = Parser::HTTP1.new(self, options.max_response_headers, options.max_response_header_value_size)
       @buffer = buffer
       @version = [1, 1]
-      @pending = []
+      @pending = pending
       @requests = []
       @callbacks = @request = nil
       @handshake_completed = @pipelining = false
@@ -51,21 +51,28 @@ module HTTPX
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
-      reset_requests
     end
 
+    # move incompleted requests back to pending queue.
     def reset_requests
-      @requests.reverse_each do |request|
-        next if request.response
+      completed_idx = 0
+      @requests.each_with_index do |request, idx|
+        if request.response
+          completed_idx = idx + 1
+          next
+        end
 
         request.transition(:idle)
-        @pending.unshift(request)
       end
+      # drop completed requests
+      @requests.shift(completed_idx)
+      @pending.unshift(*@requests)
       @requests.clear
     end
 
     def close
       reset
+      reset_requests
       emit(:close)
     end
 
@@ -88,14 +95,16 @@ module HTTPX
       @parser << data
     end
 
-    def send(request, head = false)
+    def send(request, head = false) # rubocop:disable Naming/PredicateMethod
       unless @max_requests.positive? && @max_requests > @requests.size
         head ? @pending.unshift(request) : @pending << request
-        return
+        return false
       end
 
       @requests << request
       @pipelining = @max_concurrent_requests > 1 && @requests.size > 1
+      emit(:request_accepted, request)
+      true
     end
 
     def consume
@@ -195,8 +204,7 @@ module HTTPX
       manage_connection(request, response)
 
       if exhausted?
-        @pending.unshift(*@requests)
-        @requests.clear
+        reset_requests
 
         emit(:exhausted)
       elsif @requests.any?
@@ -237,13 +245,16 @@ module HTTPX
     def ping
       reset
       emit(:reset)
-      emit(:exhausted)
     end
 
     def waiting_for_ping?
       false
     end
 
+    def no_more_requests?
+      @requests.empty?
+    end
+
     private
 
     def manage_connection(request, response)
@@ -252,8 +263,7 @@ module HTTPX
       when /keep-alive/i
         if @handshake_completed
           if @max_requests.zero?
-            @pending.unshift(*@requests)
-            @requests.clear
+            reset_requests
             emit(:exhausted)
           end
           return
@@ -267,10 +277,7 @@ module HTTPX
         end]
         @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
 
-        if parameters.key?("timeout")
-          keep_alive_timeout = parameters["timeout"].to_i
-          emit(:timeout, keep_alive_timeout)
-        end
+        emit(:keep_alive_timeout, parameters["timeout"].to_i) if parameters.key?("timeout")
         @handshake_completed = true
       when /close/i
         disable

data/lib/httpx/connection/http2.rb

@@ -50,11 +50,11 @@ module HTTPX
 
     attr_reader :streams, :pending
 
-    def initialize(buffer, options)
-      @callbacks = nil
+    def initialize(buffer, pending, options)
+      @callbacks = @last_error = nil
       @options = options
       @settings = @options.http2_settings
-      @pending = []
+      @pending = pending
       @streams = {}
       @drains = {}
       @pings = []
@@ -74,10 +74,15 @@ module HTTPX
     end
 
     def interests
-      if @connection.closed?
+      if @connection.state == :closed
         return unless @handshake_completed
 
-        return if @buffer.empty?
+        if @buffer.empty?
+          # a closed HTTP/2 connection can still receive DATA frames from inflight streams.
+          return :r unless @streams.empty?
+
+          return
+        end
 
         # HTTP/2 GOAWAY frame buffered.
         return :w
@@ -85,7 +90,7 @@ module HTTPX
 
       unless @connection.state == :connected && @handshake_completed
         # HTTP/2 in intermediate state or still completing initialization-
-        return @buffer.empty? ? :r : :rw
+        return @buffer.empty? ? :r : :w
       end
 
       unless @connection.send_buffer.empty?
@@ -97,15 +102,10 @@ module HTTPX
         return :r
       end
 
-      # only wait for writable if we're not waiting on more streams,
-      # or waiting on ping ACKs.
-      nothing_to_wait_for = @streams.empty? && @pings.empty?
-
       # there are pending bufferable requests
-      if !@pending.empty? && can_buffer_more_requests?
-        # only wait for writable if we're not waiting on more streams,
-        # or waiting on ping ACKs.
-        return nothing_to_wait_for ? :w : :rw
+      if !@pending.empty? && can_buffer_pending_requests?
+        # only wait for writable if not waiting on the peer.
+        return waiting_for_peer? ? :rw : :w
       end
 
       unless @drains.empty?
@@ -123,17 +123,47 @@ module HTTPX
 
       if @buffer.empty?
         # skip if no more requests or pings to process
-        return if nothing_to_wait_for
+        return unless waiting_for_peer?
 
         :r
       else
         # buffered frames
-        nothing_to_wait_for ? :w : :rw
+        waiting_for_peer? ? :rw : :w
       end
     end
 
     def close
-      unless @connection.closed?
+      if @connection.closed?
+        # if there are inflight streams waiting to be completed AFTER the peer alread shut down the
+        # connection from their end, raise-or-retry depending on whether the error is recoverable.
+        if (ex = @last_error)
+          if @streams.any? || @pending.any?
+            if ex.is_a?(GoawayError) && !ex.unrecoverable?
+              inflight_unprocessed_requests = @streams.map do |req, _|
+                req.transition(:idle)
+                req
+              end
+              @streams.clear
+
+              # only signal exhaustion when inflight requests had to be moved back.
+              unless inflight_unprocessed_requests.empty?
+                @pending.unshift(*inflight_unprocessed_requests)
+                emit(:exhausted, ex)
+              end
+            else
+              while (req, _ = @streams.shift)
+                emit(:error, req, ex)
+              end
+              while (req = @pending.shift)
+                emit(:error, req, ex)
+              end
+            end
+          end
+
+          # clean pending payload now that everything's gone.
+          @buffer.clear
+        end
+      else
         @connection.goaway
         emit(:timeout, @options.timeout.close_handshake_timeout)
       end
@@ -156,10 +186,16 @@ module HTTPX
         # data received by the peer.
         emit_stream_error(stream, request, error)
       end
+
+      # if the connection transitioned to :closed, start tearing it down. Explicitly bypass the
+      # :closing transition to give it time to complete the inflight streams.
+      return unless @connection.state == :closed
+
+      close
     end
 
     def send(request, head = false)
-      unless can_buffer_more_requests?
+      unless can_buffer_pending_requests?
         head ? @pending.unshift(request) : @pending << request
         return false
       end
@@ -168,6 +204,7 @@ module HTTPX
         handle_stream(stream, request)
         @streams[request] = stream
         @max_requests -= 1
+        emit(:request_accepted, request)
       end
       handle(request, stream)
       true
@@ -176,6 +213,7 @@ module HTTPX
       false
     rescue ::HTTP2::Error::Error, ArgumentError => e
       emit(:error, request, e)
+      false
     end
 
     def consume
@@ -184,6 +222,8 @@ module HTTPX
 
         handle(request, stream)
       end
+
+      send_pending
     end
 
     def handle_error(ex, request = nil)
@@ -191,37 +231,60 @@ module HTTPX
       case ex
       when OperationTimeoutError
         if !@handshake_completed && @connection.state != :closed
+          # timed out waiting for HTTP/2 connection handshake to complete.
           @connection.goaway(:settings_timeout, "closing due to settings timeout")
           emit(:close_handshake)
           settings_ex = SettingsTimeoutError.new(ex.timeout, ex.message)
           settings_ex.set_backtrace(ex.backtrace)
           ex = settings_ex
+        elsif @connection.state == :closing
+          # failed to receive data for inflight streams in time.
+          ex = @last_error || ex
+        end
+      when EOFError
+        if @connection.state == :closing
+          # socket closed while waiting for inflight streams to finish
+          ex = @last_error || ex
         end
       when GoawayError
         last_stream_id = ex.last_stream_id
       end
 
       inflight_unprocessed_requests = [] #: Array[Request]
+      unprocessed_streams = [] #: Array[::HTTP2::Stream]
+
+      @streams.delete_if do |req, stream|
+        # allow inflight streams to finish
+        next(false) if !last_stream_id.infinite? && stream.id <= last_stream_id
 
-      while (req, stream = @streams.shift)
         @drains.delete(stream)
 
-        next if request && request == req
+        next(true) if request && request == req
 
         if stream.id > last_stream_id
           req.transition(:idle)
           # unprocessed request
           inflight_unprocessed_requests << req
+          unprocessed_streams << stream
 
-          next
+          next(true)
         end
 
         emit(:error, req, ex)
+        true
+      end
+
+      @pending.unshift(*inflight_unprocessed_requests) if inflight_unprocessed_requests.any?
+
+      unless @streams.empty?
+        unprocessed_streams.each(&:close)
+
+        # streams covered by the GOAWAY are still being processed.
+        return
       end
 
       if ex.is_a?(GoawayError) && !ex.unrecoverable?
         # resend unprocessed requests on a different connection
-        @pending.unshift(*inflight_unprocessed_requests) if inflight_unprocessed_requests.any?
         emit(:exhausted, ex) if @pending.any?
         return
       end
@@ -244,18 +307,29 @@ module HTTPX
       @pings.any?
     end
 
+    def no_more_requests?
+      @streams.empty?
+    end
+
     def reset_requests; end
 
     private
 
-    def can_buffer_more_requests?
-      (@handshake_completed || !@wait_for_handshake) &&
+    # whether there are PING acks, or streams waiting for more data
+    # (that can be a response or WINDOW_UPDATE frames).
+    def waiting_for_peer?
+      waiting_for_ping? || @streams.any? { |r, s| !r.can_buffer? || !s.send_buffer.empty? }
+    end
+
+    def can_buffer_pending_requests?
+      !@connection.closed? &&
+        (@handshake_completed || !@wait_for_handshake) &&
         @streams.size < @max_concurrent_requests &&
         @streams.size < @max_requests
     end
 
     def send_pending
-      while (request = @pending.shift)
+      while !@buffer.full? && can_buffer_pending_requests? && (request = @pending.shift)
         break unless send(request, true)
       end
     end
@@ -527,16 +601,21 @@ module HTTPX
             emit(:error, request, error)
           end
         else
-          ex = GoawayError.new(error, last_stream_id)
+          # keep goaway error around, in case inflight streams never complete.
+          @last_error = ex = GoawayError.new(error, last_stream_id)
           ex.set_backtrace(caller)
 
           handle_error(ex)
-          teardown
         end
       end
-      return unless is_connection_closed && @streams.empty?
+      return unless is_connection_closed
 
-      emit(:close) if is_connection_closed
+      if @streams.empty?
+        emit(:close)
+      else
+        # this connection should not start new streams.
+        emit(:closing)
+      end
     end
 
     def on_frame_sent(frame)