puppeteer-ruby 0.38.0 → 0.40.2

data/lib/puppeteer/network_event_manager.rb

@@ -0,0 +1,122 @@
+# Helper class to track network events by request ID
+class Puppeteer::NetworkEventManager
+  def initialize
+    #
+    # There are four possible orders of events:
+    #  A. `_onRequestWillBeSent`
+    #  B. `_onRequestWillBeSent`, `_onRequestPaused`
+    #  C. `_onRequestPaused`, `_onRequestWillBeSent`
+    #  D. `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`
+    #     (see crbug.com/1196004)
+    #
+    # For `_onRequest` we need the event from `_onRequestWillBeSent` and
+    # optionally the `interceptionId` from `_onRequestPaused`.
+    #
+    # If request interception is disabled, call `_onRequest` once per call to
+    # `_onRequestWillBeSent`.
+    # If request interception is enabled, call `_onRequest` once per call to
+    # `_onRequestPaused` (once per `interceptionId`).
+    #
+    # Events are stored to allow for subsequent events to call `_onRequest`.
+    #
+    # Note that (chains of) redirect requests have the same `requestId` (!) as
+    # the original request. We have to anticipate series of events like these:
+    #  A. `_onRequestWillBeSent`,
+    #     `_onRequestWillBeSent`, ...
+    #  B. `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, ...
+    #  C. `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestPaused`, `_onRequestWillBeSent`, ...
+    #  D. `_onRequestPaused`, `_onRequestWillBeSent`,
+    #     `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+    #     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`, ...
+    #     (see crbug.com/1196004)
+    @request_will_be_sent_map = {}
+    @request_paused_map = {}
+    @http_requests_map = {}
+    #
+    # The below maps are used to reconcile Network.responseReceivedExtraInfo
+    # events with their corresponding request. Each response and redirect
+    # response gets an ExtraInfo event, and we don't know which will come first.
+    # This means that we have to store a Response or an ExtraInfo for each
+    # response, and emit the event when we get both of them. In addition, to
+    # handle redirects, we have to make them Arrays to represent the chain of
+    # events.
+    @response_received_extra_info_map = {}
+    @queued_redirect_info_map = {}
+    @queued_event_group_map = {}
+  end
+
+  def forget(network_request_id)
+    @request_will_be_sent_map.delete(network_request_id)
+    @request_paused_map.delete(network_request_id)
+    @queued_event_group_map.delete(network_request_id)
+    @queued_redirect_info_map.delete(network_request_id)
+    @response_received_extra_info_map.delete(network_request_id)
+  end
+
+  def response_extra_info(network_request_id)
+    @response_received_extra_info_map[network_request_id] ||= []
+  end
+
+  private def queued_redirect_info(fetch_request_id)
+    @queued_redirect_info_map[fetch_request_id] ||= []
+  end
+
+  def enqueue_redirect_info(fetch_request_id, redirect_info)
+    queued_redirect_info(fetch_request_id) << redirect_info
+  end
+
+  def take_queued_redirect_info(fetch_request_id)
+    queued_redirect_info(fetch_request_id).shift
+  end
+
+  def num_requests_in_progress
+    @http_requests_map.count { |_, request| !request.response }
+  end
+
+  def store_request_will_be_sent(network_request_id, event)
+    @request_will_be_sent_map[network_request_id] = event
+  end
+
+  def get_request_will_be_sent(network_request_id)
+    @request_will_be_sent_map[network_request_id]
+  end
+
+  def forget_request_will_be_sent(network_request_id)
+    @request_will_be_sent_map.delete(network_request_id)
+  end
+
+  def store_request_paused(network_request_id, event)
+    @request_paused_map[network_request_id] = event
+  end
+
+  def get_request_paused(network_request_id)
+    @request_paused_map[network_request_id]
+  end
+
+  def forget_request_paused(network_request_id)
+    @request_paused_map.delete(network_request_id)
+  end
+
+  def store_request(network_request_id, request)
+    @http_requests_map[network_request_id] = request
+  end
+
+  def get_request(network_request_id)
+    @http_requests_map[network_request_id]
+  end
+
+  def forget_request(network_request_id)
+    @http_requests_map.delete(network_request_id)
+  end
+
+  def enqueue_event_group(network_request_id, queued_event_group)
+    @queued_event_group_map[network_request_id] = queued_event_group
+  end
+
+  def get_queued_event_group(network_request_id)
+    @queued_event_group_map[network_request_id]
+  end
+end

data/lib/puppeteer/network_manager.rb

@@ -53,6 +53,22 @@ class Puppeteer::NetworkManager
     end
   end
 
+  class RedirectInfo
+    def initialize(event:, fetch_request_id:)
+      @event = event
+      @fetch_request_id = fetch_request_id
+    end
+    attr_reader :event, :fetch_request_id
+  end
+
+  class QueuedEventGroup
+    def initialize(response_received_event:)
+      @response_received_event = response_received_event
+    end
+    attr_reader :response_received_event
+    attr_accessor :loading_finished_event, :loading_failed_event
+  end
+
   # @param {!Puppeteer.CDPSession} client
   # @param {boolean} ignoreHTTPSErrors
   # @param {!Puppeteer.FrameManager} frameManager
@@ -60,12 +76,7 @@ class Puppeteer::NetworkManager
     @client = client
     @ignore_https_errors = ignore_https_errors
     @frame_manager = frame_manager
-
-    # @type {!Map<string, !Request>}
-    @request_id_to_request = {}
-
-    # @type {!Map<string, !Protocol.Network.requestWillBeSentPayload>}
-    @request_id_to_request_with_be_sent_event = {}
+    @network_event_manager = Puppeteer::NetworkEventManager.new
 
     @extra_http_headers = {}
 
@@ -73,7 +84,6 @@ class Puppeteer::NetworkManager
     @user_request_interception_enabled = false
     @protocol_request_interception_enabled = false
     @user_cache_disabled = false
-    @request_id_to_interception_id = {}
     @internal_network_condition = InternalNetworkCondition.new(@client)
 
     @client.on_event('Fetch.requestPaused') do |event|
@@ -97,6 +107,9 @@ class Puppeteer::NetworkManager
     @client.on_event('Network.loadingFailed') do |event|
       handle_loading_failed(event)
     end
+    @client.on_event('Network.responseReceivedExtraInfo') do |event|
+      handle_response_received_extra_info(event)
+    end
   end
 
   def init
@@ -106,6 +119,14 @@ class Puppeteer::NetworkManager
     end
   end
 
+  def inspect
+    values = %i[network_event_manager].map do |sym|
+      value = instance_variable_get(:"@#{sym}")
+      "@#{sym}=#{value}"
+    end
+    "#<Puppeteer::HTTPRequest #{values.join(' ')}>"
+  end
+
   # @param username [String|NilClass]
   # @param password [String|NilClass]
   def authenticate(username:, password:)
@@ -131,6 +152,10 @@ class Puppeteer::NetworkManager
     @extra_http_headers.dup
   end
 
+  def num_requests_in_progress
+    @network_event_manager.num_requests_in_progress
+  end
+
   # @param value [TrueClass|FalseClass]
   def offline_mode=(value)
     @internal_network_condition.offline_mode=(value)
@@ -185,14 +210,17 @@ class Puppeteer::NetworkManager
 
   private def handle_request_will_be_sent(event)
     # Request interception doesn't happen for data URLs with Network Service.
-    if @protocol_request_interception_enabled && !event['request']['url'].start_with?('data:')
-      request_id = event['requestId']
-      interception_id = @request_id_to_interception_id.delete(request_id)
-      if interception_id
-        handle_request(event, interception_id)
-      else
-        @request_id_to_request_with_be_sent_event[request_id] = event
+    if @user_request_interception_enabled && !event['request']['url'].start_with?('data:')
+      network_request_id = event['requestId']
+      @network_event_manager.store_request_will_be_sent(network_request_id, event)
+
+      # CDP may have sent a Fetch.requestPaused event already. Check for it.
+      if_present(@network_event_manager.get_request_paused(network_request_id)) do |request_paused_event|
+        fetch_request_id = request_paused_event['requestId']
+        handle_request(event, fetch_request_id)
+        @network_event_manager.forget_request_paused(network_request_id)
       end
+
       return
     end
     handle_request(event, nil)
@@ -233,26 +261,61 @@ class Puppeteer::NetworkManager
       end
     end
 
-    request_id = event['networkId']
-    interception_id = event['requestId']
-    if request_id && (request_will_be_sent_event = @request_id_to_request_with_be_sent_event.delete(request_id))
-      handle_request(request_will_be_sent_event, interception_id)
+    network_request_id = event['networkId']
+    fetch_request_id = event['requestId']
+    return unless network_request_id
+
+    request_will_be_sent_event = @network_event_manager.get_request_will_be_sent(network_request_id)
+
+    # redirect requests have the same `requestId`
+    if request_will_be_sent_event &&
+       (request_will_be_sent_event['request']['url'] != event['request']['url'] ||
+        request_will_be_sent_event['request']['method'] != event['request']['method'])
+
+      @network_event_manager.forget_request_will_be_sent(network_request_id)
+      request_will_be_sent_event = nil
+    end
+
+    if request_will_be_sent_event
+      handle_request(request_will_be_sent_event, fetch_request_id)
     else
-      @request_id_to_interception_id[request_id] = interception_id
+      @network_event_manager.store_request_paused(network_request_id, event)
     end
   end
 
-  private def handle_request(event, interception_id)
+  private def handle_request(event, fetch_request_id)
     redirect_chain = []
     if event['redirectResponse']
-      if_present(@request_id_to_request[event['requestId']]) do |request|
-        handle_request_redirect(request, event['redirectResponse'])
+      # We want to emit a response and requestfinished for the
+      # redirectResponse, but we can't do so unless we have a
+      # responseExtraInfo ready to pair it up with. If we don't have any
+      # responseExtraInfos saved in our queue, they we have to wait until
+      # the next one to emit response and requestfinished, *and* we should
+      # also wait to emit this Request too because it should come after the
+      # response/requestfinished.
+      redirect_response_extra_info = nil
+      if event['redirectHasExtraInfo']
+        redirect_response_extra_info = @network_event_manager.response_extra_info(event['requestId']).shift
+        unless redirect_response_extra_info
+          redirect_info = RedirectInfo.new(
+            event: event,
+            fetch_request_id: fetch_request_id,
+          )
+          @network_event_manager.enqueue_redirect_info(event['requestId'], redirect_info)
+          return
+        end
+      end
+
+      # If we connect late to the target, we could have missed the
+      # requestWillBeSent event.
+      if_present(@network_event_manager.get_request(event['requestId'])) do |request|
+        handle_request_redirect(request, event['redirectResponse'], redirect_response_extra_info)
         redirect_chain = request.internal.redirect_chain
       end
     end
     frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
-    request = Puppeteer::HTTPRequest.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
-    @request_id_to_request[event['requestId']] = request
+    request = Puppeteer::HTTPRequest.new(@client, frame, fetch_request_id, @user_request_interception_enabled, event, redirect_chain)
+    @network_event_manager.store_request(event['requestId'], request)
     emit_event(NetworkManagerEmittedEvents::Request, request)
     begin
       request.finalize_interceptions
@@ -262,55 +325,133 @@ class Puppeteer::NetworkManager
   end
 
   private def handle_request_served_from_cache(event)
-    if_present(@request_id_to_request[event['requestId']]) do |request|
+    request = @network_event_manager.get_request(event['requestId'])
+    if request
       request.internal.from_memory_cache = true
     end
+    emit_event(NetworkManagerEmittedEvents::RequestServedFromCache, request)
   end
 
   # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
-  private def handle_request_redirect(request, response_payload)
-    response = Puppeteer::HTTPResponse.new(@client, request, response_payload)
+  private def handle_request_redirect(request, response_payload, extra_info)
+    response = Puppeteer::HTTPResponse.new(@client, request, response_payload, extra_info)
     request.internal.response = response
     request.internal.redirect_chain << request
     response.internal.body_loaded_promise.reject(Puppeteer::HTTPResponse::Redirected.new)
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, false)
     emit_event(NetworkManagerEmittedEvents::Response, response)
     emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
-  # @param event [Hash]
-  private def handle_response_received(event)
-    request = @request_id_to_request[event['requestId']]
+  private def emit_response_event(response_received_event, extra_info)
+    request = @network_event_manager.get_request(response_received_event['requestId'])
     # FileUpload sends a response without a matching request.
     return unless request
 
-    response = Puppeteer::HTTPResponse.new(@client, request, event['response'])
+    unless @network_event_manager.response_extra_info(response_received_event['requestId']).empty?
+      debug_puts("Unexpected extraInfo events for request #{response_received_event['requestId']}")
+    end
+
+    response = Puppeteer::HTTPResponse.new(@client, request, response_received_event['response'], extra_info)
     request.internal.response = response
     emit_event(NetworkManagerEmittedEvents::Response, response)
   end
 
+  # @param event [Hash]
+  private def handle_response_received(event)
+    request = @network_event_manager.get_request(event['requestId'])
+    extra_info = nil
+    if request && !request.internal.from_memory_cache? && event['hasExtraInfo']
+      extra_info = @network_event_manager.response_extra_info(event['requestId']).shift
+
+      unless extra_info
+        # Wait until we get the corresponding ExtraInfo event.
+        @network_event_manager.enqueue_event_group(event['requestId'], QueuedEventGroup.new(response_received_event: event))
+        return
+      end
+    end
+    emit_response_event(event, extra_info)
+  end
+
+  private def handle_response_received_extra_info(event)
+    # We may have skipped a redirect response/request pair due to waiting for
+    # this ExtraInfo event. If so, continue that work now that we have the
+    # request.
+    if_present(@network_event_manager.take_queued_redirect_info(event['requestId'])) do |redirect_info|
+      @network_event_manager.response_extra_info(event['requestId']) << event
+      handle_request(redirect_info.event, redirect_info)
+      return
+    end
+
+    # We may have skipped response and loading events because we didn't have
+    # this ExtraInfo event yet. If so, emit those events now.
+    if_present(@network_event_manager.get_queued_event_group(event['requestId'])) do |queued_events|
+      emit_response_event(queued_events.response_received_event, event)
+      if_present(queued_events.loading_finished_event) do |loading_finished_event|
+        emit_loading_finished(loading_finished_event)
+      end
+      if_present(queued_events.loading_failed_event) do |loading_failed_event|
+        emit_loading_failed(loading_failed_event)
+      end
+      return
+    end
+
+    # Wait until we get another event that can use this ExtraInfo event.
+    @network_event_manager.response_extra_info(event['requestId']) << event
+  end
+
+  private def forget_request(request, forget_events)
+    request_id = request.internal.request_id
+    interception_id = request.internal.interception_id
+
+    @network_event_manager.forget_request(request_id)
+    @attempted_authentications.delete(interception_id)
+    if forget_events
+      @network_event_manager.forget(request_id)
+    end
+  end
+
   private def handle_loading_finished(event)
-    request = @request_id_to_request[event['requestId']]
+    # If the response event for this request is still waiting on a
+    # corresponding ExtraInfo event, then wait to emit this event too.
+    queued_events = @network_event_manager.get_queued_event_group(event['requestId'])
+    if queued_events
+      queued_events.loading_finished_event = event
+    else
+      emit_loading_finished(event)
+    end
+  end
+
+  private def emit_loading_finished(event)
+    request = @network_event_manager.get_request(event['requestId'])
     # For certain requestIds we never receive requestWillBeSent event.
     # @see https://crbug.com/750469
     return unless request
 
-
     # Under certain conditions we never get the Network.responseReceived
     # event from protocol. @see https://crbug.com/883475
     if_present(request.response) do |response|
       response.internal.body_loaded_promise.fulfill(nil)
     end
 
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, true)
     emit_event(NetworkManagerEmittedEvents::RequestFinished, request)
   end
 
   private def handle_loading_failed(event)
-    request = @request_id_to_request[event['requestId']]
+    # If the response event for this request is still waiting on a
+    # corresponding ExtraInfo event, then wait to emit this event too.
+    queued_events = @network_event_manager.get_queued_event_group(event['requestId'])
+    if queued_events
+      queued_events.loading_failed_event = event
+    else
+      emit_loading_failed(event)
+    end
+  end
+
+  private def emit_loading_failed(event)
+    request = @network_event_manager.get_request(event['requestId'])
     # For certain requestIds we never receive requestWillBeSent event.
     # @see https://crbug.com/750469
     return unless request
@@ -319,8 +460,7 @@ class Puppeteer::NetworkManager
     if_present(request.response) do |response|
       response.internal.body_loaded_promise.fulfill(nil)
     end
-    @request_id_to_request.delete(request.internal.request_id)
-    @attempted_authentications.delete(request.internal.interception_id)
+    forget_request(request, true)
     emit_event(NetworkManagerEmittedEvents::RequestFailed, request)
   end
 end

data/lib/puppeteer/query_handler_manager.rb

@@ -26,8 +26,8 @@ class Puppeteer::QueryHandlerManager
       @query_handler.query_one(element_handle, @selector)
     end
 
-    def wait_for(dom_world, visible:, hidden:, timeout:)
-      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout)
+    def wait_for(dom_world, visible:, hidden:, timeout:, root:)
+      @query_handler.wait_for(dom_world, @selector, visible: visible, hidden: hidden, timeout: timeout, root: root)
     end
 
     def query_all(element_handle)

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 module Puppeteer
-  VERSION = '0.38.0'
+  VERSION = '0.40.2'
 end

data/lib/puppeteer/wait_task.rb

@@ -9,7 +9,7 @@ class Puppeteer::WaitTask
     end
   end
 
-  def initialize(dom_world:, predicate_body:, title:, polling:, timeout:, args: [], binding_function: nil)
+  def initialize(dom_world:, predicate_body:, title:, polling:, timeout:, args: [], binding_function: nil, root: nil)
     if polling.is_a?(String)
       if polling != 'raf' && polling != 'mutation'
         raise ArgumentError.new("Unknown polling option: #{polling}")
@@ -25,6 +25,7 @@ class Puppeteer::WaitTask
     @dom_world = dom_world
     @polling = polling
     @timeout = timeout
+    @root = root
     @predicate_body = "return (#{predicate_body})(...args);"
     @args = args
     @binding_function = binding_function
@@ -68,6 +69,7 @@ class Puppeteer::WaitTask
     begin
       success = context.evaluate_handle(
         WAIT_FOR_PREDICATE_PAGE_FUNCTION,
+        @root,
         @predicate_body,
         @polling,
         @timeout,
@@ -121,8 +123,9 @@ class Puppeteer::WaitTask
   private define_async_method :async_rerun
 
   WAIT_FOR_PREDICATE_PAGE_FUNCTION = <<~JAVASCRIPT
-  async function _(predicateBody, polling, timeout, ...args) {
+  async function _(root, predicateBody, polling, timeout, ...args) {
       const predicate = new Function('...args', predicateBody);
+      root = root || document
       let timedOut = false;
       if (timeout)
           setTimeout(() => (timedOut = true), timeout);
@@ -136,7 +139,7 @@ class Puppeteer::WaitTask
        * @return {!Promise<*>}
        */
       async function pollMutation() {
-          const success = await predicate(...args);
+          const success = await predicate(root, ...args);
           if (success) return Promise.resolve(success);
           let fulfill;
           const result = new Promise((x) => (fulfill = x));
@@ -145,13 +148,13 @@ class Puppeteer::WaitTask
                   observer.disconnect();
                   fulfill();
               }
-              const success = await predicate(...args);
+              const success = await predicate(root, ...args);
               if (success) {
                   observer.disconnect();
                   fulfill(success);
               }
           });
-          observer.observe(document, {
+          observer.observe(root, {
               childList: true,
               subtree: true,
               attributes: true,
@@ -168,7 +171,7 @@ class Puppeteer::WaitTask
                   fulfill();
                   return;
               }
-              const success = await predicate(...args);
+              const success = await predicate(root, ...args);
               if (success) fulfill(success);
               else requestAnimationFrame(onRaf);
           }
@@ -183,7 +186,7 @@ class Puppeteer::WaitTask
                   fulfill();
                   return;
               }
-              const success = await predicate(...args);
+              const success = await predicate(root, ...args);
               if (success) fulfill(success);
               else setTimeout(onTimeout, pollInterval);
           }

data/lib/puppeteer.rb

@@ -47,6 +47,7 @@ require 'puppeteer/launcher'
 require 'puppeteer/lifecycle_watcher'
 require 'puppeteer/mouse'
 require 'puppeteer/network_conditions'
+require 'puppeteer/network_event_manager'
 require 'puppeteer/network_manager'
 require 'puppeteer/page'
 require 'puppeteer/protocol_stream_reader'

data/puppeteer-ruby.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'concurrent-ruby', '~> 1.1.0'
   spec.add_dependency 'websocket-driver', '>= 0.6.0'
   spec.add_dependency 'mime-types', '>= 3.0'
-  spec.add_development_dependency 'bundler', '~> 2.2.3'
+  spec.add_development_dependency 'bundler', '~> 2.3.4'
   spec.add_development_dependency 'chunky_png'
   spec.add_development_dependency 'dry-inflector'
   spec.add_development_dependency 'pry-byebug'
@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rollbar'
   spec.add_development_dependency 'rspec', '~> 3.10.0 '
   spec.add_development_dependency 'rspec_junit_formatter' # for CircleCI.
-  spec.add_development_dependency 'rubocop', '~> 1.23.0'
+  spec.add_development_dependency 'rubocop', '~> 1.24.0'
   spec.add_development_dependency 'rubocop-rspec'
   spec.add_development_dependency 'sinatra'
   spec.add_development_dependency 'webrick'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.38.0
+  version: 0.40.2
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: 2.3.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: 2.3.4
 - !ruby/object:Gem::Dependency
   name: chunky_png
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.23.0
+        version: 1.24.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.23.0
+        version: 1.24.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -306,6 +306,7 @@ files:
 - lib/puppeteer/mouse.rb
 - lib/puppeteer/network_condition.rb
 - lib/puppeteer/network_conditions.rb
+- lib/puppeteer/network_event_manager.rb
 - lib/puppeteer/network_manager.rb
 - lib/puppeteer/page.rb
 - lib/puppeteer/page/metrics.rb
@@ -346,7 +347,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: A ruby port of puppeteer