feat: add web probe performance hotspot analysis
This commit is contained in:
Codex
@@ -0,0 +1,855 @@
|
||||
// SPEC: PJ2026-01040111 long-running Workbench observation.
|
||||
// Responsibility: Runner filesystem setup, heartbeat, browser process monitoring, freeze policy, and passive page listeners source fragment.
|
||||
|
||||
export function nodeWebObserveRunnerRuntimeSource(): string {
|
||||
return String.raw`async function prepareDirs() {
|
||||
await mkdir(stateDir, { recursive: true, mode: 0o700 });
|
||||
await Promise.all(Object.values(dirs).map((dir) => mkdir(dir, { recursive: true, mode: 0o700 })));
|
||||
}
|
||||
|
||||
async function rotateExistingJsonlArtifacts() {
|
||||
for (const [key, file] of Object.entries(files)) {
|
||||
if (!file.endsWith(".jsonl")) continue;
|
||||
let meta = null;
|
||||
try {
|
||||
meta = await stat(file);
|
||||
} catch (error) {
|
||||
if (error?.code === "ENOENT") continue;
|
||||
throw error;
|
||||
}
|
||||
if (!meta?.isFile()) continue;
|
||||
const archiveFile = await uniqueArchiveFile(jsonlRotation.stamp + "-" + path.basename(file));
|
||||
await rename(file, archiveFile);
|
||||
jsonlRotation.files.push({ key, from: path.relative(stateDir, file), to: path.relative(stateDir, archiveFile), byteCount: meta.size });
|
||||
}
|
||||
}
|
||||
|
||||
async function uniqueArchiveFile(name) {
|
||||
let candidate = path.join(dirs.archive, name);
|
||||
const parsed = path.parse(name);
|
||||
for (let index = 1; ; index += 1) {
|
||||
try {
|
||||
await stat(candidate);
|
||||
candidate = path.join(dirs.archive, parsed.name + "-" + index + parsed.ext);
|
||||
} catch (error) {
|
||||
if (error?.code === "ENOENT") return candidate;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function compactFileTimestamp(value) {
|
||||
return new Date(value).toISOString().replace(/[-:]/gu, "").replace(/[.]\d{3}Z$/u, "Z");
|
||||
}
|
||||
|
||||
async function writeManifest(extra = {}) {
|
||||
const manifest = {
|
||||
ok: extra.status !== "failed",
|
||||
command: "web-probe-observe",
|
||||
specRef,
|
||||
jobId,
|
||||
pid: process.pid,
|
||||
stateDir,
|
||||
baseUrl,
|
||||
targetPath,
|
||||
network: publicNetwork(playwrightProxy),
|
||||
navigation: { maxAttempts: navigationMaxAttempts, valuesRedacted: true },
|
||||
pageAuthority: { browser: "chromium", context: "shared-auth", pageMode: "dual-control-observer", controlPageId: pageId, observerPageId, continuityBreaksRecorded: true },
|
||||
pageProvenance: compactPageProvenance(currentPageProvenance),
|
||||
sampling: { mode: "passive", sampleIntervalMs, screenshotIntervalMs, maxSamples, observerRefreshIntervalMs, observerInitiatedDefault: false, responseBodyReadDefault: false },
|
||||
alertThresholds,
|
||||
browserFreezePolicy,
|
||||
projectManagement,
|
||||
jsonlRotation,
|
||||
commandDirs: dirs,
|
||||
artifacts: files,
|
||||
safety: { pureClient: true, inboundApi: false, database: false, queueConsumer: false, k8sWorkload: false, valuesRedacted: true, secretValuesPrinted: false },
|
||||
startedAt,
|
||||
...extra,
|
||||
};
|
||||
await writeFile(files.manifest, JSON.stringify(manifest, null, 2) + "\n", { mode: 0o600 });
|
||||
}
|
||||
|
||||
async function writeHeartbeat(extra = {}) {
|
||||
const heartbeat = {
|
||||
ok: terminalStatus !== "failed",
|
||||
jobId,
|
||||
pid: process.pid,
|
||||
stateDir,
|
||||
status: terminalStatus,
|
||||
pageId,
|
||||
observerPageId,
|
||||
baseUrl,
|
||||
currentUrl: currentPageUrl(),
|
||||
observerUrl: pageUrl(observerPage),
|
||||
observerRefreshIntervalMs,
|
||||
lastObserverRefreshAt: Number.isFinite(lastObserverRefreshAtMs) ? new Date(lastObserverRefreshAtMs).toISOString() : null,
|
||||
pageProvenance: compactPageProvenance(currentPageProvenance),
|
||||
sampleSeq,
|
||||
commandSeq,
|
||||
activeCommandId,
|
||||
updatedAt: new Date().toISOString(),
|
||||
uptimeMs: Date.now() - startedAtMs,
|
||||
...extra,
|
||||
};
|
||||
await writeFile(files.heartbeat, JSON.stringify(heartbeat, null, 2) + "\n", { mode: 0o600 });
|
||||
}
|
||||
|
||||
function startHeartbeatPulse() {
|
||||
const timer = setInterval(() => {
|
||||
if (stopping) return;
|
||||
void writeHeartbeat({ status: terminalStatus, heartbeatPulse: true })
|
||||
.catch((error) => appendJsonl(files.errors, eventRecord("heartbeat-pulse-error", { error: errorSummary(error) })));
|
||||
}, 5000);
|
||||
if (timer && typeof timer.unref === "function") timer.unref();
|
||||
return timer;
|
||||
}
|
||||
|
||||
function startBrowserProcessMonitor() {
|
||||
const intervalMs = Math.max(250, Math.floor(Number(alertThresholds.browserProcessSampleIntervalMs) || 1000));
|
||||
let stopped = false;
|
||||
let running = false;
|
||||
const tick = async (reason) => {
|
||||
if (stopped || running || stopping || browserFreezeBlocker) return;
|
||||
running = true;
|
||||
try {
|
||||
await collectBrowserProcessSample(reason || "interval");
|
||||
} catch (error) {
|
||||
await appendJsonl(files.errors, eventRecord("browser-process-monitor-error", { error: errorSummary(error), valuesRedacted: true })).catch(() => {});
|
||||
} finally {
|
||||
running = false;
|
||||
}
|
||||
};
|
||||
void tick("startup");
|
||||
const timer = setInterval(() => {
|
||||
void tick("interval");
|
||||
}, intervalMs);
|
||||
if (timer && typeof timer.unref === "function") timer.unref();
|
||||
return () => {
|
||||
stopped = true;
|
||||
clearInterval(timer);
|
||||
};
|
||||
}
|
||||
|
||||
async function collectBrowserProcessSample(reason) {
|
||||
browserProcessMonitorSeq += 1;
|
||||
const tsMs = Date.now();
|
||||
const browserPid = browserProcessPid();
|
||||
const processSummary = await collectChromiumProcessSummary(browserPid);
|
||||
const growth = updateBrowserProcessHistory(tsMs, processSummary);
|
||||
const pages = [];
|
||||
if (page && !page.isClosed()) {
|
||||
pages.push(await collectBrowserPageRuntimeMetrics(page, { pageRole: "control", targetPageId: pageId, pageEpoch: controlPageEpoch }).catch((error) => browserPageRuntimeMetricError("control", pageId, controlPageEpoch, error)));
|
||||
}
|
||||
if (observerPage && !observerPage.isClosed()) {
|
||||
pages.push(await collectBrowserPageRuntimeMetrics(observerPage, { pageRole: "observer", targetPageId: observerPageId, pageEpoch: observerPageEpoch }).catch((error) => browserPageRuntimeMetricError("observer", observerPageId, observerPageEpoch, error)));
|
||||
}
|
||||
const sample = eventRecord("browser-process-sample", {
|
||||
seq: browserProcessMonitorSeq,
|
||||
reason,
|
||||
monitorIntervalMs: Math.max(250, Math.floor(Number(alertThresholds.browserProcessSampleIntervalMs) || 1000)),
|
||||
browserPid,
|
||||
process: processSummary,
|
||||
growth,
|
||||
pages,
|
||||
valuesRedacted: true,
|
||||
});
|
||||
await appendJsonl(files.browserProcess, sample);
|
||||
await enforceBrowserFreezePolicy(sample);
|
||||
}
|
||||
|
||||
async function enforceBrowserFreezePolicy(sample) {
|
||||
if (browserFreezePolicy.enabled !== true || browserFreezeBlocker) return;
|
||||
const processSummary = sample && typeof sample.process === "object" ? sample.process : {};
|
||||
const growth = sample && typeof sample.growth === "object" ? sample.growth : {};
|
||||
const totalRssMb = Number(processSummary.totalRssMb);
|
||||
const processRssMb = Number(processSummary.maxProcessRssMb);
|
||||
const totalGrowthMb = Number(growth.totalRssGrowthMb);
|
||||
const processGrowthMb = Number(growth.maxProcessRssGrowthMb);
|
||||
|
||||
for (const pageMetric of Array.isArray(sample.pages) ? sample.pages : []) {
|
||||
const effectiveMemory = pageMetric?.effectiveMemory && typeof pageMetric.effectiveMemory === "object" ? pageMetric.effectiveMemory : {};
|
||||
const effectiveHeapUsedMb = Number(effectiveMemory.effectiveHeapUsedMb);
|
||||
const effectiveJsHeapUsedMb = Number(effectiveMemory.effectiveJsHeapUsedMb);
|
||||
const heapGrowthMb = Number(effectiveMemory.heapUsedGrowthMb);
|
||||
const jsHeapGrowthMb = Number(effectiveMemory.jsHeapUsedGrowthMb);
|
||||
if (
|
||||
(Number.isFinite(effectiveHeapUsedMb) && effectiveHeapUsedMb >= browserFreezePolicy.memory.processRssBlockerMb)
|
||||
|| (Number.isFinite(effectiveJsHeapUsedMb) && effectiveJsHeapUsedMb >= browserFreezePolicy.memory.processRssBlockerMb)
|
||||
) {
|
||||
await triggerBrowserFreezeBlocker({
|
||||
kind: "memory-page-effective",
|
||||
rootCause: "frontend_browser_page_effective_memory_pressure",
|
||||
observed: {
|
||||
pageRole: pageMetric?.pageRole ?? null,
|
||||
pageId: pageMetric?.pageId ?? null,
|
||||
pageEpoch: pageMetric?.pageEpoch ?? null,
|
||||
totalRssMb,
|
||||
processRssMb,
|
||||
totalGrowthMb,
|
||||
processGrowthMb,
|
||||
effectiveHeapUsedMb: Number.isFinite(effectiveHeapUsedMb) ? effectiveHeapUsedMb : null,
|
||||
effectiveJsHeapUsedMb: Number.isFinite(effectiveJsHeapUsedMb) ? effectiveJsHeapUsedMb : null,
|
||||
baseline: pageMetric?.baseline ?? null,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
threshold: { processRssBlockerMb: browserFreezePolicy.memory.processRssBlockerMb, policyScope: "per-page-effective-memory", valuesRedacted: true },
|
||||
sample: browserProcessSampleRef(sample),
|
||||
page: browserPageMetricRef(pageMetric),
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (
|
||||
(Number.isFinite(heapGrowthMb) && heapGrowthMb >= browserFreezePolicy.memory.growthBlockerMb)
|
||||
|| (Number.isFinite(jsHeapGrowthMb) && jsHeapGrowthMb >= browserFreezePolicy.memory.growthBlockerMb)
|
||||
) {
|
||||
await triggerBrowserFreezeBlocker({
|
||||
kind: "memory-page-effective-growth",
|
||||
rootCause: "frontend_browser_page_memory_leak_or_unbounded_render_growth",
|
||||
observed: {
|
||||
pageRole: pageMetric?.pageRole ?? null,
|
||||
pageId: pageMetric?.pageId ?? null,
|
||||
pageEpoch: pageMetric?.pageEpoch ?? null,
|
||||
totalRssMb,
|
||||
processRssMb,
|
||||
totalGrowthMb,
|
||||
processGrowthMb,
|
||||
heapGrowthMb: Number.isFinite(heapGrowthMb) ? heapGrowthMb : null,
|
||||
jsHeapGrowthMb: Number.isFinite(jsHeapGrowthMb) ? jsHeapGrowthMb : null,
|
||||
baseline: pageMetric?.baseline ?? null,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
threshold: { growthBlockerMb: browserFreezePolicy.memory.growthBlockerMb, windowMs: browserFreezePolicy.blockerWindowMs, policyScope: "per-page-effective-memory", valuesRedacted: true },
|
||||
sample: browserProcessSampleRef(sample),
|
||||
page: browserPageMetricRef(pageMetric),
|
||||
});
|
||||
return;
|
||||
}
|
||||
const responsiveness = pageMetric?.responsiveness && typeof pageMetric.responsiveness === "object" ? pageMetric.responsiveness : {};
|
||||
const responsivenessLatencyMs = Number(responsiveness.latencyMs);
|
||||
if (responsiveness.timeout === true || (Number.isFinite(responsivenessLatencyMs) && responsivenessLatencyMs >= browserFreezePolicy.responsiveness.latencyBlockerMs)) {
|
||||
const signal = recordBrowserFreezeSignal("playwright-responsiveness", sample, pageMetric, {
|
||||
rootCause: "frontend_browser_page_unresponsive_to_playwright",
|
||||
observed: {
|
||||
responsivenessLatencyMs: Number.isFinite(responsivenessLatencyMs) ? responsivenessLatencyMs : null,
|
||||
responsivenessTimeout: responsiveness.timeout === true,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
threshold: {
|
||||
latencyBlockerMs: browserFreezePolicy.responsiveness.latencyBlockerMs,
|
||||
eventBlockerCount: browserFreezePolicy.responsiveness.eventBlockerCount,
|
||||
windowMs: browserFreezePolicy.blockerWindowMs,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
});
|
||||
if (signal.burst.length >= browserFreezePolicy.responsiveness.eventBlockerCount) {
|
||||
await triggerBrowserFreezeBlocker(signal);
|
||||
return;
|
||||
}
|
||||
}
|
||||
const cdp = pageMetric?.cdp && typeof pageMetric.cdp === "object" ? pageMetric.cdp : {};
|
||||
const calls = Array.isArray(cdp.calls) ? cdp.calls : [];
|
||||
const metricTimeoutCalls = calls.filter((call) => call?.timeout === true && call?.method !== "Runtime.evaluate");
|
||||
const sessionTimeoutCount = calls.length === 0 ? Number(cdp.timeoutCount || 0) : 0;
|
||||
const metricTimeoutCount = metricTimeoutCalls.length + (Number.isFinite(sessionTimeoutCount) ? sessionTimeoutCount : 0);
|
||||
if (metricTimeoutCount > 0) {
|
||||
const signal = recordBrowserFreezeSignal("cdp-metrics-timeout", sample, pageMetric, {
|
||||
rootCause: "frontend_browser_cdp_metrics_unresponsive",
|
||||
observed: {
|
||||
cdpMetricsTimeoutCount: metricTimeoutCount,
|
||||
methods: metricTimeoutCalls.map((call) => call.method || "unknown").slice(0, 8),
|
||||
valuesRedacted: true,
|
||||
},
|
||||
threshold: {
|
||||
metricsTimeoutBlockerCount: browserFreezePolicy.cdp.metricsTimeoutBlockerCount,
|
||||
windowMs: browserFreezePolicy.blockerWindowMs,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
});
|
||||
if (signal.burst.length >= browserFreezePolicy.cdp.metricsTimeoutBlockerCount) {
|
||||
await triggerBrowserFreezeBlocker(signal);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function recordBrowserFreezeSignal(kind, sample, pageMetric, detail) {
|
||||
const tsMs = Date.parse(String(sample?.ts || ""));
|
||||
const signal = {
|
||||
kind,
|
||||
ts: sample?.ts ?? new Date().toISOString(),
|
||||
tsMs: Number.isFinite(tsMs) ? tsMs : Date.now(),
|
||||
pageRole: pageMetric?.pageRole ?? null,
|
||||
pageId: pageMetric?.pageId ?? null,
|
||||
pageEpoch: pageMetric?.pageEpoch ?? null,
|
||||
sample: browserProcessSampleRef(sample),
|
||||
page: browserPageMetricRef(pageMetric),
|
||||
...detail,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
browserFreezeSignalHistory.push(signal);
|
||||
const windowMs = browserFreezePolicy.blockerWindowMs;
|
||||
const cutoff = signal.tsMs - windowMs;
|
||||
while (browserFreezeSignalHistory.length > 0 && Number(browserFreezeSignalHistory[0].tsMs || 0) < cutoff) browserFreezeSignalHistory.shift();
|
||||
return {
|
||||
kind,
|
||||
rootCause: detail.rootCause,
|
||||
observed: detail.observed,
|
||||
threshold: detail.threshold,
|
||||
sample: browserProcessSampleRef(sample),
|
||||
page: browserPageMetricRef(pageMetric),
|
||||
burst: browserFreezeSignalHistory.filter((item) => item.kind === kind && item.tsMs >= cutoff).slice(-20),
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
async function triggerBrowserFreezeBlocker(trigger) {
|
||||
if (browserFreezeBlocker) return;
|
||||
stopping = true;
|
||||
terminalStatus = "failed";
|
||||
const base = {
|
||||
id: "browser-freeze-policy-blocker",
|
||||
severity: "red",
|
||||
blocking: true,
|
||||
kind: trigger.kind,
|
||||
summary: "web-probe runner matched YAML browserFreezePolicy and stopped the browser; this run must stay red instead of refreshing or falling back",
|
||||
rootCause: trigger.rootCause,
|
||||
rootCauseStatus: "confirmed-from-runner-browser-freeze-policy",
|
||||
rootCauseConfidence: "high",
|
||||
fallbackAllowed: false,
|
||||
observerRefreshAllowed: false,
|
||||
policySource: "config/hwlab-node-lanes.yaml#webProbe.browserFreezePolicy via UNIDESK_WEB_OBSERVE_BROWSER_FREEZE_POLICY_JSON",
|
||||
observed: trigger.observed || null,
|
||||
threshold: trigger.threshold || null,
|
||||
sample: trigger.sample || null,
|
||||
page: trigger.page || null,
|
||||
burst: Array.isArray(trigger.burst) ? trigger.burst.slice(0, 20) : [],
|
||||
valuesRedacted: true,
|
||||
};
|
||||
browserFreezeBlocker = { ...base, browserKill: { ok: false, pending: true, valuesRedacted: true }, valuesRedacted: true };
|
||||
const browserKill = browserFreezePolicy.kill.enabled === true
|
||||
? await terminateBrowserForFreezeBlocker(base).catch((error) => ({ ok: false, error: errorSummary(error), valuesRedacted: true }))
|
||||
: { ok: true, skipped: true, reason: "kill-disabled-by-yaml-policy", valuesRedacted: true };
|
||||
browserFreezeBlocker = { ...base, browserKill, valuesRedacted: true };
|
||||
await appendJsonl(files.browserProcess, eventRecord("browser-freeze-blocker", browserFreezeBlocker)).catch(() => {});
|
||||
await appendJsonl(files.errors, eventRecord("browser-freeze-blocker", {
|
||||
...browserFreezeBlocker,
|
||||
error: {
|
||||
name: "BrowserFreezeBlocker",
|
||||
message: "YAML browserFreezePolicy matched: " + String(trigger.kind || "unknown"),
|
||||
details: browserFreezeBlocker,
|
||||
valuesRedacted: true,
|
||||
},
|
||||
})).catch(() => {});
|
||||
await writeHeartbeat({ status: "failed", blocker: browserFreezeBlocker }).catch(() => {});
|
||||
await writeManifest({ status: "failed", blocker: browserFreezeBlocker }).catch(() => {});
|
||||
}
|
||||
|
||||
async function terminateBrowserForFreezeBlocker(blocker) {
|
||||
const childProcess = browser && typeof browser.process === "function" ? browser.process() : null;
|
||||
const pid = Number(childProcess?.pid);
|
||||
if (!Number.isFinite(pid) || pid <= 0) {
|
||||
return { ok: false, reason: "browser-process-unavailable", blockerKind: blocker.kind, valuesRedacted: true };
|
||||
}
|
||||
const result = {
|
||||
ok: false,
|
||||
pid: Math.floor(pid),
|
||||
gracefulSignal: browserFreezePolicy.kill.gracefulSignal,
|
||||
forceSignal: browserFreezePolicy.kill.forceSignal,
|
||||
graceMs: browserFreezePolicy.kill.graceMs,
|
||||
pollIntervalMs: browserFreezePolicy.kill.pollIntervalMs,
|
||||
gracefulSent: false,
|
||||
forceSent: false,
|
||||
exitedAfterGrace: false,
|
||||
exitedAfterForce: false,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
try {
|
||||
childProcess.kill(browserFreezePolicy.kill.gracefulSignal);
|
||||
result.gracefulSent = true;
|
||||
} catch (error) {
|
||||
result.gracefulError = errorSummary(error);
|
||||
}
|
||||
result.exitedAfterGrace = await waitForPidExit(result.pid, browserFreezePolicy.kill.graceMs, browserFreezePolicy.kill.pollIntervalMs);
|
||||
if (!result.exitedAfterGrace) {
|
||||
try {
|
||||
childProcess.kill(browserFreezePolicy.kill.forceSignal);
|
||||
result.forceSent = true;
|
||||
} catch (error) {
|
||||
result.forceError = errorSummary(error);
|
||||
}
|
||||
result.exitedAfterForce = await waitForPidExit(result.pid, browserFreezePolicy.kill.graceMs, browserFreezePolicy.kill.pollIntervalMs);
|
||||
}
|
||||
result.ok = result.exitedAfterGrace || result.exitedAfterForce;
|
||||
return result;
|
||||
}
|
||||
|
||||
async function waitForPidExit(pid, timeoutMs, pollIntervalMs) {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() <= deadline) {
|
||||
if (!pidAlive(pid)) return true;
|
||||
await sleep(pollIntervalMs);
|
||||
}
|
||||
return !pidAlive(pid);
|
||||
}
|
||||
|
||||
function pidAlive(pid) {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function browserProcessSampleRef(sample) {
|
||||
return {
|
||||
ts: sample?.ts ?? null,
|
||||
seq: sample?.seq ?? null,
|
||||
sampleSeq: sample?.sampleSeq ?? null,
|
||||
browserPid: sample?.browserPid ?? null,
|
||||
totalRssMb: sample?.process?.totalRssMb ?? null,
|
||||
maxProcessRssMb: sample?.process?.maxProcessRssMb ?? null,
|
||||
totalRssGrowthMb: sample?.growth?.totalRssGrowthMb ?? null,
|
||||
maxProcessRssGrowthMb: sample?.growth?.maxProcessRssGrowthMb ?? null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
function browserPageMetricRef(pageMetric) {
|
||||
const responsiveness = pageMetric?.responsiveness && typeof pageMetric.responsiveness === "object" ? pageMetric.responsiveness : {};
|
||||
const cdp = pageMetric?.cdp && typeof pageMetric.cdp === "object" ? pageMetric.cdp : {};
|
||||
const effectiveMemory = pageMetric?.effectiveMemory && typeof pageMetric.effectiveMemory === "object" ? pageMetric.effectiveMemory : {};
|
||||
return {
|
||||
pageRole: pageMetric?.pageRole ?? null,
|
||||
pageId: pageMetric?.pageId ?? null,
|
||||
pageEpoch: pageMetric?.pageEpoch ?? null,
|
||||
timeoutMs: pageMetric?.timeoutMs ?? null,
|
||||
responsivenessLatencyMs: responsiveness.latencyMs ?? null,
|
||||
responsivenessTimeout: responsiveness.timeout === true,
|
||||
cdpTimeoutCount: cdp.timeoutCount ?? null,
|
||||
cdpErrorCount: cdp.errorCount ?? null,
|
||||
effectiveHeapUsedMb: Number.isFinite(Number(effectiveMemory.effectiveHeapUsedMb)) ? Number(effectiveMemory.effectiveHeapUsedMb) : null,
|
||||
effectiveJsHeapUsedMb: Number.isFinite(Number(effectiveMemory.effectiveJsHeapUsedMb)) ? Number(effectiveMemory.effectiveJsHeapUsedMb) : null,
|
||||
heapUsedGrowthMb: Number.isFinite(Number(effectiveMemory.heapUsedGrowthMb)) ? Number(effectiveMemory.heapUsedGrowthMb) : null,
|
||||
jsHeapUsedGrowthMb: Number.isFinite(Number(effectiveMemory.jsHeapUsedGrowthMb)) ? Number(effectiveMemory.jsHeapUsedGrowthMb) : null,
|
||||
baselineCapturedAt: pageMetric?.baseline?.capturedAt ?? null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
function browserProcessPid() {
|
||||
try {
|
||||
const childProcess = browser && typeof browser.process === "function" ? browser.process() : null;
|
||||
const pid = Number(childProcess?.pid);
|
||||
return Number.isFinite(pid) && pid > 0 ? Math.floor(pid) : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function collectChromiumProcessSummary(browserPid) {
|
||||
const all = await readProcProcessTable();
|
||||
const childrenByPpid = new Map();
|
||||
for (const item of all) {
|
||||
if (!Number.isFinite(item.ppid)) continue;
|
||||
const list = childrenByPpid.get(item.ppid) || [];
|
||||
list.push(item.pid);
|
||||
childrenByPpid.set(item.ppid, list);
|
||||
}
|
||||
const roots = [process.pid, browserPid].filter((pid, index, items) => Number.isFinite(Number(pid)) && Number(pid) > 0 && items.indexOf(pid) === index).map((pid) => Number(pid));
|
||||
const descendants = new Set(roots);
|
||||
const queue = roots.slice();
|
||||
while (queue.length > 0) {
|
||||
const pid = queue.shift();
|
||||
for (const child of childrenByPpid.get(pid) || []) {
|
||||
if (descendants.has(child)) continue;
|
||||
descendants.add(child);
|
||||
queue.push(child);
|
||||
}
|
||||
}
|
||||
const processes = all
|
||||
.filter((item) => descendants.has(item.pid))
|
||||
.map((item) => ({ ...item, role: classifyChromiumProcess(item) }))
|
||||
.filter((item) => item.role)
|
||||
.map((item) => ({
|
||||
pid: item.pid,
|
||||
ppid: item.ppid,
|
||||
name: item.name || null,
|
||||
role: item.role,
|
||||
rssBytes: item.rssBytes,
|
||||
vmSizeBytes: item.vmSizeBytes,
|
||||
commandHash: item.cmdline ? sha256Text(item.cmdline) : null,
|
||||
commandPreview: redactProcessCommandPreview(item.cmdline),
|
||||
valuesRedacted: true,
|
||||
}))
|
||||
.sort((a, b) => Number(b.rssBytes || 0) - Number(a.rssBytes || 0));
|
||||
const roles = {};
|
||||
for (const item of processes) {
|
||||
const role = item.role || "unknown";
|
||||
const summary = roles[role] || { count: 0, rssBytes: 0, maxRssBytes: 0 };
|
||||
summary.count += 1;
|
||||
summary.rssBytes += Number(item.rssBytes || 0);
|
||||
summary.maxRssBytes = Math.max(summary.maxRssBytes, Number(item.rssBytes || 0));
|
||||
roles[role] = summary;
|
||||
}
|
||||
const totalRssBytes = processes.reduce((sum, item) => sum + Number(item.rssBytes || 0), 0);
|
||||
const maxProcess = processes[0] || null;
|
||||
return {
|
||||
sampledRootPids: roots,
|
||||
chromiumProcessCount: processes.length,
|
||||
totalRssBytes,
|
||||
totalRssMb: bytesToMb(totalRssBytes),
|
||||
maxProcessRssBytes: maxProcess ? Number(maxProcess.rssBytes || 0) : 0,
|
||||
maxProcessRssMb: maxProcess ? bytesToMb(maxProcess.rssBytes) : 0,
|
||||
maxProcess,
|
||||
roles,
|
||||
processes: processes.slice(0, 20),
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
async function readProcProcessTable() {
|
||||
let entries = [];
|
||||
try {
|
||||
entries = await readdir("/proc");
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
const numeric = entries.map((name) => Number(name)).filter((pid) => Number.isInteger(pid) && pid > 0);
|
||||
const rows = await Promise.all(numeric.map((pid) => readOneProcProcess(pid).catch(() => null)));
|
||||
return rows.filter(Boolean);
|
||||
}
|
||||
|
||||
async function readOneProcProcess(pid) {
|
||||
const [statText, statusText, cmdlineText] = await Promise.all([
|
||||
readFile(path.join("/proc", String(pid), "stat"), "utf8").catch(() => ""),
|
||||
readFile(path.join("/proc", String(pid), "status"), "utf8").catch(() => ""),
|
||||
readFile(path.join("/proc", String(pid), "cmdline"), "utf8").catch(() => ""),
|
||||
]);
|
||||
if (!statText && !statusText) return null;
|
||||
const ppid = procPpidFromStat(statText);
|
||||
const name = procStatusField(statusText, "Name") || null;
|
||||
const rssKb = procStatusKb(statusText, "VmRSS");
|
||||
const vmSizeKb = procStatusKb(statusText, "VmSize");
|
||||
return {
|
||||
pid,
|
||||
ppid,
|
||||
name,
|
||||
cmdline: String(cmdlineText || "").replace(/\0/gu, " ").replace(/\s+/gu, " ").trim(),
|
||||
rssBytes: Number.isFinite(rssKb) ? rssKb * 1024 : 0,
|
||||
vmSizeBytes: Number.isFinite(vmSizeKb) ? vmSizeKb * 1024 : 0,
|
||||
};
|
||||
}
|
||||
|
||||
function procPpidFromStat(value) {
|
||||
const text = String(value || "");
|
||||
const end = text.lastIndexOf(")");
|
||||
if (end < 0) return null;
|
||||
const parts = text.slice(end + 1).trim().split(/\s+/u);
|
||||
const ppid = Number(parts[1]);
|
||||
return Number.isFinite(ppid) ? ppid : null;
|
||||
}
|
||||
|
||||
function procStatusField(value, key) {
|
||||
const prefix = String(key || "") + ":";
|
||||
for (const line of String(value || "").split(/\n/u)) {
|
||||
if (line.startsWith(prefix)) return line.slice(prefix.length).trim();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function procStatusKb(value, key) {
|
||||
const raw = procStatusField(value, key);
|
||||
const match = String(raw || "").match(/^(\d+)\s+kB$/u);
|
||||
return match ? Number(match[1]) : null;
|
||||
}
|
||||
|
||||
function classifyChromiumProcess(item) {
|
||||
const cmdline = String(item?.cmdline || "");
|
||||
const combined = (cmdline + " " + String(item?.name || "")).toLowerCase();
|
||||
if (!/(?:chromium|chrome|headless_shell)/u.test(combined)) return null;
|
||||
if (/--type=renderer\b/u.test(cmdline)) return "renderer";
|
||||
if (/--type=gpu-process\b/u.test(cmdline)) return "gpu";
|
||||
if (/--type=utility\b/u.test(cmdline)) return "utility";
|
||||
if (/--type=zygote\b/u.test(cmdline)) return "zygote";
|
||||
if (/--type=broker\b/u.test(cmdline)) return "broker";
|
||||
if (/--type=/u.test(cmdline)) return "other";
|
||||
return "browser";
|
||||
}
|
||||
|
||||
function redactProcessCommandPreview(value) {
|
||||
const text = String(value || "");
|
||||
if (!text) return null;
|
||||
const parts = text.split(/\s+/u).slice(0, 18).map((part) => {
|
||||
if (/--(?:proxy|token|secret|password|cookie|auth|key)[^=]*=/iu.test(part)) return part.replace(/=.*/u, "=[redacted]");
|
||||
return part.replace(/:\/\/[^/@\s]+@/u, "://[redacted]@");
|
||||
});
|
||||
return truncate(parts.join(" "), 260);
|
||||
}
|
||||
|
||||
function updateBrowserProcessHistory(tsMs, processSummary) {
|
||||
const windowMs = Math.max(1000, Number(alertThresholds.browserRssGrowthWindowMs) || 30000);
|
||||
const totalRssBytes = Number(processSummary?.totalRssBytes || 0);
|
||||
const maxProcessRssBytes = Number(processSummary?.maxProcessRssBytes || 0);
|
||||
browserProcessHistory.push({ tsMs, totalRssBytes, maxProcessRssBytes });
|
||||
const retentionMs = Math.max(windowMs * 3, 180000);
|
||||
while (browserProcessHistory.length > 0 && tsMs - browserProcessHistory[0].tsMs > retentionMs) browserProcessHistory.shift();
|
||||
const windowStartMs = tsMs - windowMs;
|
||||
const candidates = browserProcessHistory.filter((item) => item.tsMs >= windowStartMs && item.tsMs <= tsMs);
|
||||
const baseline = candidates[0] || browserProcessHistory[0] || null;
|
||||
const totalRssGrowthBytes = baseline ? totalRssBytes - Number(baseline.totalRssBytes || 0) : 0;
|
||||
const maxProcessRssGrowthBytes = baseline ? maxProcessRssBytes - Number(baseline.maxProcessRssBytes || 0) : 0;
|
||||
return {
|
||||
windowMs,
|
||||
baselineAt: baseline ? new Date(baseline.tsMs).toISOString() : null,
|
||||
baselineTotalRssBytes: baseline ? baseline.totalRssBytes : null,
|
||||
baselineMaxProcessRssBytes: baseline ? baseline.maxProcessRssBytes : null,
|
||||
totalRssGrowthBytes,
|
||||
totalRssGrowthMb: bytesToMb(totalRssGrowthBytes),
|
||||
maxProcessRssGrowthBytes,
|
||||
maxProcessRssGrowthMb: bytesToMb(maxProcessRssGrowthBytes),
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
async function collectBrowserPageRuntimeMetrics(targetPage, { pageRole, targetPageId, pageEpoch }) {
|
||||
const timeoutMs = Math.max(1000, Math.floor(Number(alertThresholds.playwrightResponsivenessRedMs) || 5000));
|
||||
const startedAtMs = Date.now();
|
||||
let session = null;
|
||||
const result = {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
pageEpoch: Number.isFinite(Number(pageEpoch)) ? Number(pageEpoch) : 0,
|
||||
url: pageUrl(targetPage),
|
||||
timeoutMs,
|
||||
responsiveness: null,
|
||||
cdp: { timeoutCount: 0, errorCount: 0, calls: [] },
|
||||
valuesRedacted: true,
|
||||
};
|
||||
try {
|
||||
session = await withHardTimeout(targetPage.context().newCDPSession(targetPage), timeoutMs, "newCDPSession exceeded " + timeoutMs + "ms");
|
||||
const enable = await timedCdpSend(session, "Performance.enable", {}, timeoutMs);
|
||||
if (enable.ok !== true) result.cdp.calls.push({ method: "Performance.enable", ...enable });
|
||||
result.responsiveness = await timedCdpSend(session, "Runtime.evaluate", { expression: "1", returnByValue: true }, timeoutMs);
|
||||
result.cdp.calls.push({ method: "Runtime.evaluate", ...result.responsiveness });
|
||||
const performance = await timedCdpSend(session, "Performance.getMetrics", {}, timeoutMs);
|
||||
result.cdp.calls.push({ method: "Performance.getMetrics", ...performance });
|
||||
result.performance = performance.value;
|
||||
const heap = await timedCdpSend(session, "Runtime.getHeapUsage", {}, timeoutMs);
|
||||
result.cdp.calls.push({ method: "Runtime.getHeapUsage", ...heap });
|
||||
result.heapUsage = heap.value;
|
||||
const domCounters = await timedCdpSend(session, "Memory.getDOMCounters", {}, timeoutMs);
|
||||
result.cdp.calls.push({ method: "Memory.getDOMCounters", ...domCounters });
|
||||
result.domCounters = domCounters.value;
|
||||
result.cdp.timeoutCount = result.cdp.calls.filter((item) => item.timeout === true).length;
|
||||
result.cdp.errorCount = result.cdp.calls.filter((item) => item.ok !== true).length;
|
||||
} catch (error) {
|
||||
result.sessionError = errorSummary(error);
|
||||
result.cdp.timeoutCount = isTimeoutErrorMessage(error?.message) ? 1 : 0;
|
||||
result.cdp.errorCount = 1;
|
||||
} finally {
|
||||
result.latencyMs = Date.now() - startedAtMs;
|
||||
applyBrowserPageRuntimeBaseline(result);
|
||||
if (session) await withHardTimeout(session.detach(), 1000, "CDP session detach exceeded 1000ms").catch(() => {});
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function applyBrowserPageRuntimeBaseline(result) {
|
||||
const key = [result.pageRole || "unknown", result.pageId || "unknown", Number.isFinite(Number(result.pageEpoch)) ? Number(result.pageEpoch) : 0].join(":");
|
||||
const current = browserPageRuntimeMemorySnapshot(result);
|
||||
const existing = browserPageRuntimeBaselines.get(key);
|
||||
if (!existing && current) browserPageRuntimeBaselines.set(key, { ...current, capturedAt: new Date().toISOString(), source: "first-page-runtime-sample", valuesRedacted: true });
|
||||
const baseline = browserPageRuntimeBaselines.get(key) || null;
|
||||
result.baseline = baseline ? {
|
||||
capturedAt: baseline.capturedAt,
|
||||
source: baseline.source,
|
||||
heapUsedMb: baseline.heapUsedMb,
|
||||
jsHeapUsedMb: baseline.jsHeapUsedMb,
|
||||
domNodes: baseline.domNodes,
|
||||
valuesRedacted: true,
|
||||
} : null;
|
||||
result.effectiveMemory = browserPageEffectiveMemory(current, baseline);
|
||||
}
|
||||
|
||||
function browserPageRuntimeMemorySnapshot(result) {
|
||||
const heapUsedBytes = Number(result?.heapUsage?.usedSize);
|
||||
const metrics = result?.performance?.metrics && typeof result.performance.metrics === "object" ? result.performance.metrics : {};
|
||||
const jsHeapUsedBytes = Number(metrics.JSHeapUsedSize);
|
||||
const domNodes = Number(result?.domCounters?.nodes ?? metrics.Nodes);
|
||||
if (!Number.isFinite(heapUsedBytes) && !Number.isFinite(jsHeapUsedBytes) && !Number.isFinite(domNodes)) return null;
|
||||
return {
|
||||
heapUsedBytes: Number.isFinite(heapUsedBytes) ? heapUsedBytes : null,
|
||||
heapUsedMb: Number.isFinite(heapUsedBytes) ? bytesToMb(heapUsedBytes) : null,
|
||||
jsHeapUsedBytes: Number.isFinite(jsHeapUsedBytes) ? jsHeapUsedBytes : null,
|
||||
jsHeapUsedMb: Number.isFinite(jsHeapUsedBytes) ? bytesToMb(jsHeapUsedBytes) : null,
|
||||
domNodes: Number.isFinite(domNodes) ? domNodes : null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
function browserPageEffectiveMemory(current, baseline) {
|
||||
if (!current) return { available: false, baselineAvailable: Boolean(baseline), valuesRedacted: true };
|
||||
const heapUsedGrowthBytes = numericDelta(current.heapUsedBytes, baseline?.heapUsedBytes);
|
||||
const jsHeapUsedGrowthBytes = numericDelta(current.jsHeapUsedBytes, baseline?.jsHeapUsedBytes);
|
||||
const domNodesGrowth = numericDelta(current.domNodes, baseline?.domNodes);
|
||||
return {
|
||||
available: true,
|
||||
baselineAvailable: Boolean(baseline),
|
||||
heapUsedMb: current.heapUsedMb,
|
||||
jsHeapUsedMb: current.jsHeapUsedMb,
|
||||
effectiveHeapUsedMb: Number.isFinite(heapUsedGrowthBytes) ? bytesToMb(heapUsedGrowthBytes) : current.heapUsedMb,
|
||||
effectiveJsHeapUsedMb: Number.isFinite(jsHeapUsedGrowthBytes) ? bytesToMb(jsHeapUsedGrowthBytes) : current.jsHeapUsedMb,
|
||||
heapUsedGrowthMb: Number.isFinite(heapUsedGrowthBytes) ? bytesToMb(heapUsedGrowthBytes) : null,
|
||||
jsHeapUsedGrowthMb: Number.isFinite(jsHeapUsedGrowthBytes) ? bytesToMb(jsHeapUsedGrowthBytes) : null,
|
||||
domNodes: current.domNodes,
|
||||
domNodesGrowth: Number.isFinite(domNodesGrowth) ? domNodesGrowth : null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
function numericDelta(current, baseline) {
|
||||
const value = Number(current);
|
||||
const base = Number(baseline);
|
||||
if (!Number.isFinite(value) || !Number.isFinite(base)) return null;
|
||||
return value - base;
|
||||
}
|
||||
|
||||
function browserPageRuntimeMetricError(pageRole, targetPageId, pageEpoch, error) {
|
||||
return {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
pageEpoch: Number.isFinite(Number(pageEpoch)) ? Number(pageEpoch) : 0,
|
||||
url: null,
|
||||
timeoutMs: Math.max(1000, Math.floor(Number(alertThresholds.playwrightResponsivenessRedMs) || 5000)),
|
||||
responsiveness: { ok: false, timeout: isTimeoutErrorMessage(error?.message), error: errorSummary(error), valuesRedacted: true },
|
||||
cdp: { timeoutCount: isTimeoutErrorMessage(error?.message) ? 1 : 0, errorCount: 1, calls: [] },
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
|
||||
async function timedCdpSend(session, method, params, timeoutMs) {
|
||||
const startedAtMs = Date.now();
|
||||
try {
|
||||
const value = await withHardTimeout(session.send(method, params || {}), timeoutMs, method + " exceeded " + timeoutMs + "ms");
|
||||
return { ok: true, timeout: false, latencyMs: Date.now() - startedAtMs, value: compactCdpValue(method, value), valuesRedacted: true };
|
||||
} catch (error) {
|
||||
return { ok: false, timeout: isTimeoutErrorMessage(error?.message), latencyMs: Date.now() - startedAtMs, error: errorSummary(error), valuesRedacted: true };
|
||||
}
|
||||
}
|
||||
|
||||
function compactCdpValue(method, value) {
|
||||
if (!value || typeof value !== "object") return value ?? null;
|
||||
if (method === "Performance.getMetrics") {
|
||||
const wanted = new Set(["Timestamp", "Documents", "Frames", "JSEventListeners", "Nodes", "LayoutCount", "RecalcStyleCount", "LayoutDuration", "RecalcStyleDuration", "ScriptDuration", "TaskDuration", "JSHeapUsedSize", "JSHeapTotalSize"]);
|
||||
const metrics = {};
|
||||
for (const item of Array.isArray(value.metrics) ? value.metrics : []) {
|
||||
if (wanted.has(item?.name)) metrics[item.name] = Number.isFinite(Number(item?.value)) ? Number(item.value) : null;
|
||||
}
|
||||
return { metricCount: Array.isArray(value.metrics) ? value.metrics.length : 0, metrics, valuesRedacted: true };
|
||||
}
|
||||
if (method === "Runtime.getHeapUsage") {
|
||||
return {
|
||||
usedSize: Number.isFinite(Number(value.usedSize)) ? Number(value.usedSize) : null,
|
||||
totalSize: Number.isFinite(Number(value.totalSize)) ? Number(value.totalSize) : null,
|
||||
embedderHeapUsedSize: Number.isFinite(Number(value.embedderHeapUsedSize)) ? Number(value.embedderHeapUsedSize) : null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
if (method === "Memory.getDOMCounters") {
|
||||
return {
|
||||
documents: Number.isFinite(Number(value.documents)) ? Number(value.documents) : null,
|
||||
nodes: Number.isFinite(Number(value.nodes)) ? Number(value.nodes) : null,
|
||||
jsEventListeners: Number.isFinite(Number(value.jsEventListeners)) ? Number(value.jsEventListeners) : null,
|
||||
valuesRedacted: true,
|
||||
};
|
||||
}
|
||||
if (method === "Runtime.evaluate") {
|
||||
return { resultType: value.result?.type ?? null, unserializableValue: value.result?.unserializableValue ?? null, exceptionDetails: value.exceptionDetails ? { text: truncate(value.exceptionDetails.text || "", 200), valuesRedacted: true } : null, valuesRedacted: true };
|
||||
}
|
||||
return { valuesRedacted: true };
|
||||
}
|
||||
|
||||
function isTimeoutErrorMessage(value) {
|
||||
return /timeout|timed\s*out|exceeded\s+\d+\s*ms/iu.test(String(value || ""));
|
||||
}
|
||||
|
||||
function bytesToMb(value) {
|
||||
const numeric = Number(value);
|
||||
if (!Number.isFinite(numeric)) return null;
|
||||
return Number((numeric / 1024 / 1024).toFixed(1));
|
||||
}
|
||||
|
||||
function attachPassiveListeners(targetPage, pageRole = "control", targetPageId = pageId) {
|
||||
void installPagePerformanceProbe(targetPage, pageRole, targetPageId)
|
||||
.catch((error) => appendJsonl(files.errors, eventRecord("performance-probe-install-error", { pageRole, pageId: targetPageId, error: errorSummary(error), valuesRedacted: true })));
|
||||
targetPage.on("request", (request) => {
|
||||
void appendJsonl(files.network, eventRecord("request", {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
observerInitiated: false,
|
||||
commandId: activeCommandId,
|
||||
method: request.method(),
|
||||
url: safeUrl(request.url()),
|
||||
resourceType: request.resourceType(),
|
||||
frameUrl: safeFrameUrl(request.frame()),
|
||||
}));
|
||||
});
|
||||
targetPage.on("response", (response) => {
|
||||
const request = response.request();
|
||||
const base = {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
sampleSeq,
|
||||
observerInitiated: false,
|
||||
commandId: activeCommandId,
|
||||
method: request.method(),
|
||||
url: safeUrl(response.url()),
|
||||
resourceType: request.resourceType(),
|
||||
status: response.status(),
|
||||
statusText: response.statusText(),
|
||||
fromServiceWorker: response.fromServiceWorker(),
|
||||
};
|
||||
void (async () => {
|
||||
const bodyFields = await summarizeWorkbenchResponseBody(response, request);
|
||||
await appendJsonl(files.network, eventRecord("response", { ...base, ...bodyFields }));
|
||||
})().catch((error) => appendJsonl(files.errors, eventRecord("response-body-summary-error", {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
sampleSeq,
|
||||
commandId: activeCommandId,
|
||||
method: request.method(),
|
||||
url: safeUrl(response.url()),
|
||||
error: errorSummary(error),
|
||||
valuesRedacted: true
|
||||
})));
|
||||
});
|
||||
targetPage.on("requestfailed", (request) => {
|
||||
void appendJsonl(files.network, eventRecord("requestfailed", {
|
||||
pageRole,
|
||||
pageId: targetPageId,
|
||||
observerInitiated: false,
|
||||
commandId: activeCommandId,
|
||||
method: request.method(),
|
||||
url: safeUrl(request.url()),
|
||||
resourceType: request.resourceType(),
|
||||
failure: request.failure()?.errorText ?? null,
|
||||
}));
|
||||
});
|
||||
targetPage.on("console", (message) => {
|
||||
void appendJsonl(files.console, eventRecord("console", { pageRole, pageId: targetPageId, type: message.type(), text: truncate(message.text(), 1000), location: message.location() }));
|
||||
});
|
||||
targetPage.on("pageerror", (error) => {
|
||||
void appendJsonl(files.errors, eventRecord("pageerror", { pageRole, pageId: targetPageId, error: errorSummary(error) }));
|
||||
});
|
||||
targetPage.on("crash", () => {
|
||||
void appendJsonl(files.errors, eventRecord("page-crash", { pageRole, pageId: targetPageId }));
|
||||
});
|
||||
targetPage.on("close", () => {
|
||||
void appendJsonl(files.control, eventRecord("continuity-break", { pageRole, pageId: targetPageId, reason: "page-closed" }));
|
||||
});
|
||||
}
|
||||
`;
|
||||
}
|
||||
Reference in New Issue
Block a user