Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsMonitor a Puppeteer run at three levels: measure its end-to-end outcome in Node.js, listen for browser and network events before the work begins, and sample page metrics at consistent checkpoints. Treat these as separate signals: a slow run, a JavaScript exception, an HTTP 503, and a request that fails mid-flight are different problems and need different evidence.
What to record for each Puppeteer run
Puppeteer exposes page events and metrics, but it does not provide a single built-in monitoring backend or combined health score. Your Node.js application should add the run context and decide how to store and alert on the signals. A useful record connects the browser observations to the automation task that produced them.
- Run context: a unique run ID, scenario name, Puppeteer version, browser and browser version, and start and end timestamps.
- Outcome: success, script exception, timeout, browser disconnect, or another explicit result.
- End-to-end duration: elapsed time measured in Node around the navigation or action the scenario is meant to perform.
- Page and network evidence: browser JavaScript errors, console messages, HTTP response statuses, and requests that failed.
- Performance samples: timestamped
page.metrics()readings at meaningful, repeatable checkpoints.
Keep the scenario and environment with each sample. For example, label a first-load run separately from a warm-cache run; otherwise changes in the test conditions can look like a performance regression. Redact credentials, private query parameters, page content, and other sensitive data before logs or traces are persisted.
Instrument events before navigation or actions
Attach listeners before the navigation or interaction you want to observe. Registering them afterward can miss the very page errors or requests that explain a failure. Puppeteer’s PageEvents reference documents the relevant page events; check the API signature against the Puppeteer version installed in your project. The official introductory guide describes Puppeteer as controlling Chrome or Firefox over the DevTools Protocol or WebDriver BiDi: What is Puppeteer?
#1 Best Overall
- CRISP CLARITY: This 23.8″ Philips V line monitor delivers crisp Full HD 1920x1080 visuals. Enjoy movies, shows and videos with remarkable detail
- INCREDIBLE CONTRAST: The VA panel produces brighter whites and deeper blacks. You get true-to-life images and more gradients with 16.7 million colors
- THE PERFECT VIEW: The 178/178 degree extra wide viewing angle prevents the shifting of colors when viewed from an offset angle, so you always get consistent colors
- WORK SEAMLESSLY: This sleek monitor is virtually bezel-free on three sides, so the screen looks even bigger for the viewer. This minimalistic design also allows for seamless multi-monitor setups that enhance your workflow and boost productivity
- A BETTER READING EXPERIENCE: For busy office workers, EasyRead mode provides a more paper-like experience for when viewing lengthy documents
A runnable Node.js example
Install Puppeteer in your project with npm install puppeteer, save this as monitor.js, then run node monitor.js. It measures navigation duration in Node, records event signals, and takes one metric sample after navigation. Replace the target URL with a page you are authorized to access.
const puppeteer = require('puppeteer');
const { randomUUID } = require('node:crypto');
async function main() {
const runId = randomUUID();
const scenario = 'homepage-navigation';
const url = 'https://example.com';
const browser = await puppeteer.launch({ headless: true });
const page = await browser.newPage();
const startedAt = new Date().toISOString();
const log = (type, details = {}) => {
console.log(JSON.stringify({
runId,
scenario,
at: new Date().toISOString(),
type,
...details,
}));
};
page.on('pageerror', error => {
log('pageerror', { message: error.message });
});
page.on('console', message => {
log('console', {
level: message.type(),
text: message.text(),
});
});
page.on('requestfailed', request => {
log('requestfailed', {
url: request.url(),
method: request.method(),
errorText: request.failure()?.errorText ?? null,
});
});
page.on('response', response => {
log('response', {
url: response.url(),
status: response.status(),
});
});
// Optional lifecycle events can help explain request timing and volume.
page.on('requestfinished', request => {
log('requestfinished', { url: request.url() });
});
const start = performance.now();
let outcome = 'success';
try {
const response = await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
const elapsedMs = Math.round(performance.now() - start);
log('navigation-complete', {
elapsedMs,
mainResponseStatus: response?.status() ?? null,
});
// Take samples only at checkpoints you can reproduce across runs.
const metrics = await page.metrics();
log('page-metrics', { metrics });
} catch (error) {
outcome = error.name === 'TimeoutError' ? 'timeout' : 'script-error';
log('automation-error', {
outcome,
name: error.name,
message: error.message,
});
process.exitCode = 1;
} finally {
log('run-finished', { outcome, startedAt, endedAt: new Date().toISOString() });
await browser.close();
}
}
main().catch(error => {
console.error(JSON.stringify({ type: 'harness-error', message: error.message }));
process.exitCode = 1;
});This example writes newline-delimited JSON to standard output so a local run is easy to inspect and a logging system can ingest structured records. In a production harness, also record your installed Puppeteer and browser versions, and route the records to the system your team already uses. Avoid logging full page text or blindly persisting every URL: query strings can contain tokens or personal data.
Choose a navigation checkpoint deliberately
domcontentloaded is a specific milestone, not a guarantee that a modern page is fully usable. If the scenario depends on a particular element, wait for that selector and measure through that point. If it depends on a user action, measure the action and its expected result instead of treating navigation time as the whole journey. The right endpoint is the outcome your automation is meant to verify.
Separate page errors, console messages, HTTP statuses, and request failures
These signals answer different questions. Keep them in separate fields or event types instead of collapsing them into one generic “browser error.”
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #2
- CRISP CLARITY: This 22 inch class (21.5″ viewable) Philips V line monitor delivers crisp Full HD 1920x1080 visuals. Enjoy movies, shows and videos with remarkable detail
- 100HZ FAST REFRESH RATE: 100Hz brings your favorite movies and video games to life. Stream, binge, and play effortlessly
- SMOOTH ACTION WITH ADAPTIVE-SYNC: Adaptive-Sync technology ensures fluid action sequences and rapid response time. Every frame will be rendered smoothly with crystal clarity and without stutter
- INCREDIBLE CONTRAST: The VA panel produces brighter whites and deeper blacks. You get true-to-life images and more gradients with 16.7 million colors
- THE PERFECT VIEW: The 178/178 degree extra wide viewing angle prevents the shifting of colors when viewed from an offset angle, so you always get consistent colors
| Signal | What it tells you | How to use it |
|---|---|---|
pageerror |
A JavaScript exception occurred in page code. | Record the message and run context; use it to distinguish page code faults from Node automation failures. |
console |
The page emitted a console message, such as an error or warning. | Capture its level and text, then classify or filter noisy output. Console errors are not automatically proof the scenario failed. |
response with an HTTP status |
A server returned a response status for a request. | Record status independently and decide which statuses matter for your scenario. |
requestfailed and request.failure() |
A request failed before its normal lifecycle completed. | Record the request URL and failure detail when available; the failure text may be absent. |
| Node-side exception or timeout | The automation code failed, timed out, or could not complete its task. | Catch it around the measured operation and record it as the run outcome. |
An HTTP error response is not the same as a transport-level request failure. A 404 or 503 can still complete through requestfinished; a request that fails mid-flight emits requestfailed. Record response status separately from request.failure()?.errorText, which can be unavailable. See Puppeteer’s HTTPRequest reference and HTTPRequest.failure() reference. The HTTPRequest page is the “Next” reference, so verify its details against the version used by your application.
For actionable alerts, preserve the category: automation exception or timeout, page JavaScript exception, console diagnostic, unsuccessful HTTP status, failed request, browser disconnect or protocol problem, or performance regression. That classification helps an on-call engineer decide whether to inspect the test harness, application code, server response, or network path.
Use page metrics as consistent samples, not operation timers
await page.metrics() returns page measurements, including script, task, layout, and style-recalculation durations; JavaScript heap sizes; and counters such as DOM nodes and event listeners. The Metrics interface documents the values and units. ScriptDuration, TaskDuration, LayoutDuration, and RecalcStyleDuration are in seconds. JSHeapUsedSize and JSHeapTotalSize are in bytes. Timestamp is monotonic time, not a wall-clock timestamp.
These values are useful for comparing trends, but they are not automatically the duration of one user-visible operation. Some are cumulative or reflect a point-in-time state. Keep the wall-clock sample time from your Node process alongside the metrics, and compare equivalent checkpoints from repeated runs in the same environment. Do not interpret a single reading as a published benchmark or as a precise measure of the most recent click.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Rank #3
- Clear visuals. Fluid motion: A 144Hz refresh rate and 1ms MPRT deliver smooth, tear‑free motion across work, gaming, and streaming for clearer, more fluid viewing.
- Eye comfort: TÜV Rheinland 3‑star* certification reduces harmful blue light while preserving stunning color quality without compromise. *TÜV Rheinland 3-star eye comfort certification.
- Wide viewing angle: Get consistent views across a wide 178° /178° viewing angle.
- In-Plane Switching (IPS): See excellent color accuracy and consistency across wide viewing angles with In-plane Switching (IPS) technology.
- Ultra-thin bezels: Maximize your viewing experience with thin bezels.
Measure the journey separately
Measure end-to-end elapsed time around the actual operation using a Node-side clock, as the example does around page.goto(). For a multi-step scenario, record separate spans for meaningful steps—such as navigation, form submission, and confirmation—plus the whole scenario outcome. This lets you tell whether a run got slower overall even when individual page metrics do not explain why.
Capture a trace when metrics show a regression
Metrics can identify that a comparable run changed; a trace can help investigate what browser activity may explain it. Use tracing when a slowdown is reproducible but aggregate numbers do not reveal its cause. Puppeteer can write a trace for inspection in Chrome DevTools or a timeline viewer, and only one trace can be active per browser. See the Tracing class reference for the API available in your installed version.
Tracing is a diagnostic step rather than a replacement for routine summaries. Capture around the suspected slow interval, label the artifact with the scenario and run ID, and retain it deliberately: traces can expose page activity, so apply your project’s access and data-retention rules. Puppeteer’s Debugging guide also describes protocol logging, inspection of pending protocol calls, and forwarding browser output—useful when the issue is in the browser/protocol layer rather than page JavaScript.
Build a monitoring workflow that leads to a cause
- Define the expected result. Decide what success means for the scenario and where its measured journey starts and ends.
- Attach listeners first. Register
pageerror,console,response, andrequestfailedbefore navigation or interaction. Add request lifecycle events when they answer a specific debugging question. - Measure at the Node layer. Record elapsed time and the final outcome independently of page metrics.
- Sample at stable checkpoints. Add
page.metrics()after consistent milestones and preserve a timestamp plus environment context. - Compare like with like. Use the same scenario and environment; label cold and warm runs rather than mixing them.
- Escalate with evidence. If the slowdown is repeatable but summaries do not explain it, capture a trace and inspect browser activity.
- Alert on useful categories. Set thresholds around your own expected behavior and route alerts by failure type; Puppeteer does not document a universal combined monitoring score.
When comparing two implementations or repeated runs, use the same scenario and environment. Useful comparison axes include end-to-end elapsed time, which error classes are visible, status-code coverage, failed-request details, the volume and overhead of metrics, and whether a trace can explain a regression. This is a practical comparison framework, not a Puppeteer-provided score.
Recommended Free Tools
Rank #4
- CURVED FOR ENHANCED ENGAGEMENT: An immersive viewing experience with a curved monitor that wraps more closely around your field of vision; It creates a wider view, enhancing depth perception and minimizing peripheral distraction
- SMOOTH PERFORMANCE FOR SEAMLESS CONTENT: Stay in the action when playing games, watching videos, or working on creative projects; The 100Hz refresh rate reduces lag and motion blur so you don't miss a thing in fast-paced moments¹
- MORE GAMING POWER: Gain the edge with optimizable game settings; Color and image contrast can be adjusted to see scenes more vividly and spot enemies hiding in the dark; Game Mode adjusts any game to fill the screen so you can view every detail²
- KEEP IT EASY ON THE EYES: Care for your eyes and stay comfortable, even during long sessions; Advanced eye comfort technology certified by TÜV reduces eye strain by minimizing blue light and reducing irritating screen flicker²
- INCREASED VERSATILITY: Connect to more; Plug devices straight into your monitor for increased flexibility, making your computing environment even more convenient
Troubleshoot common monitoring gaps
No page errors appear in the logs
Check that pageerror was registered before the triggering navigation or action and that the listener belongs to the page doing the work. Also check whether the issue is actually a Node exception, a console message, or a browser/protocol problem; those are separate signals.
A page returns 404 or 503 but no request failure is logged
That can be expected: an HTTP response with an unsuccessful status can still complete normally. Inspect the response status and apply the scenario’s status policy rather than expecting requestfailed to represent every server error.
A failed request has no error text
Do not make alerting or classification depend on request.failure()?.errorText always being populated. Preserve the event, request URL (after redaction), method, and run context, and treat the error text as optional.
Metrics do not match the time the user waited
Page metrics are not a substitute for a Node-side elapsed timer around the journey. Check that you are comparing the same checkpoint and that cumulative durations are not being described as the latest operation’s latency.
Best Value
- 【INTEGRATED SPEAKERS】Whether you're at work or in the midst of an intense gaming session, our built-in speakers provide rich and seamless audio, all while keeping your desk clutter-free.
- 【EASY ON THE EYES】 Protect your eyes and enhance your comfort with Blue-Light Shift technology. This feature reduces harmful blue light emissions from your screen, helping to alleviate eye strain during long hours of use and promoting healthier viewing habits.
- 【WIDEN YOUR PERSPECTIVE】Our sleek minimal bezel design ensures undivided attention. The nearly bezel-free display seamlessly connects in a dual monitor arrangement, delivering an unobstructed view that lets you focus on more at once, completely distraction-free.
The slowdown is visible but the cause is not
Repeat the same scenario under labeled, comparable conditions. If the regression persists, capture a trace for diagnosis; one trace can be active per browser, so coordinate capture if multiple tasks share that browser.
The browser hangs or protocol activity is unclear
Record the Node exception, timeout, or disconnect separately from page events. Consult the Puppeteer debugging guidance for protocol logging, pending-protocol inspection, and forwarding browser output.
Or skip the browser setup
If your task is to capture a page image or PDF rather than automate and inspect an interactive journey, ScreenshotNeo offers a screenshot API and MCP server. A screenshot request does not replace Puppeteer event monitoring, but it can avoid maintaining browser-capture setup for that narrower job. Its capture flow can accept cookie/consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets before the shot; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify page verdict and billing through headers. AI agents can use its MCP server tools, including take_screenshot, get_page_info, and capture_pdf.
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);See the ScreenshotNeo API documentation for request details. The Free plan includes 1,000 screenshots per month without a card; paid plans start at $5 for 3,000. Sign up for free to try it.
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
