Chrome Headless与Firefox页面停留时长监控工具配置问询

Hey there, let's break down your questions step by step since you're building a website session tracking tool—this is a really practical use case!

Chrome Headless Remote Debugging: Default Duration & Timeouts #

First off, Chrome Headless with --remote-debugging-port=80 doesn't have a built-in default timeout or maximum runtime limit by default. The process will keep running until you explicitly terminate it, or until the system runs out of resources.

That 10-minute limit you're seeing is likely coming from your own control script logic, or maybe implicit Chrome behaviors like memory cleanup for idle tabs (but this won't kill the entire Headless process). To ensure uninterrupted long-running sessions, add these launch flags to avoid any potential auto-termination:

• --disable-idle-detection: Disables Chrome's idle state detection, preventing it from throttling or terminating processes due to lack of user interaction
• --disable-background-timer-throttling: Ensures your timing scripts run accurately without being slowed down in the background
• --disable-renderer-backgrounding: Prevents the page's renderer process from being suspended when it's "inactive"

How to Run Precisely 30 Minutes After Page Load #

To trigger a 30-minute session exactly after the page finishes loading, you have two reliable approaches depending on your setup:

1. Control via DevTools Protocol (Recommended) #

If you're using a script to manage the Headless instance (e.g., with Node.js), wait for the Page.loadEventFired signal before starting your timer. Here's a quick example using the chrome-remote-interface library:

const CDP = require('chrome-remote-interface');

async function start30MinSession() {
  const client = await CDP({ port: 80 });
  const { Page } = client;

  await Page.enable();
  // Wait for the page's load event to confirm full loading
  await Page.loadEventFired();
  console.log('Page fully loaded—starting 30-minute session...');

  // Wait precisely 30 minutes (30 * 60 * 1000 milliseconds)
  await new Promise(resolve => setTimeout(resolve, 30 * 60 * 1000));

  // Perform your data export/cleanup here
  console.log('30-minute session completed.');
  await client.close();
}

start30MinSession().catch(err => console.error('Error:', err));

2. Inject Script Directly Into the Page #

If you prefer to handle timing within the page itself, inject a script that listens for the load event and starts the timer:

// Run this via DevTools Protocol's Runtime.evaluate method
await Runtime.evaluate({
  expression: `
    window.addEventListener('load', () => {
      console.log('Page loaded—starting 30-minute timer.');
      setTimeout(() => {
        // Trigger data submission or session end logic here
        console.log('30 minutes elapsed.');
      }, 30 * 60 * 1000);
    });
  `
});

Firefox Equivalent Implementation #

Firefox supports similar headless and remote debugging capabilities. Here's how to replicate your setup:

Launch Flags for Uninterrupted Sessions #

Use these flags when starting Firefox Headless:

• -headless: Enable headless mode
• --remote-debugging-port=80: Enable remote debugging
• --disable-idle-detection: Prevent idle-based throttling/termination
• --disable-background-timer-throttling: Keep timers accurate
• --no-remote: Ensure a separate, isolated Firefox instance

30-Minute Session Setup #

You can use Puppeteer (which supports Firefox) or the firefox-remote-interface library. Here's a Puppeteer example:

const puppeteer = require('puppeteer');

async function startFirefoxSession() {
  const browser = await puppeteer.launch({
    product: 'firefox',
    headless: true,
    args: [
      '--remote-debugging-port=80',
      '--disable-idle-detection',
      '--disable-background-timer-throttling',
      '--no-remote'
    ]
  });

  const page = await browser.newPage();
  await page.goto('https://your-target-site.com');
  
  // Wait for the page to fully load
  await page.waitForLoadEvent('load');
  console.log('Firefox page loaded—starting 30-minute session...');

  await new Promise(resolve => setTimeout(resolve, 30 * 60 * 1000));

  // Cleanup and data handling
  console.log('Firefox session completed.');
  await browser.close();
}

startFirefoxSession().catch(err => console.error('Error:', err));

内容的提问来源于stack exchange，提问作者user1947700