import { monitorEventLoopDelay } from "node:perf_hooks";

import { monitorEventLoopDelay, performance } from "node:perf_hooks";

import { getActiveEmbeddedRunCount } from "../agents/pi-embedded-runner/run-state.js";

import { getTotalPendingReplies } from "../auto-reply/reply/dispatcher-registry.js";

import type { CanvasHostServer } from "../canvas-host/server.js";

isDiagnosticsEnabled,

setDiagnosticsEnabledForProcess,

} from "../infra/diagnostic-events.js";

import {

emitDiagnosticsTimelineEvent,

isDiagnosticsTimelineEnabled,

} from "../infra/diagnostics-timeline.js";

import { isTruthyEnvValue, isVitestRuntimeEnv, logAcceptedEnvOption } from "../infra/env.js";

import { ensureOpenClawCliOnPath } from "../infra/path-env.js";

import { setGatewaySigusr1RestartPolicy, setPreRestartDeferralCheck } from "../infra/restart.js";

const canvasRuntime = runtimeForLogger(logCanvas);

function createGatewayStartupTrace() {

const enabled = isTruthyEnvValue(process.env.OPENCLAW_GATEWAY_STARTUP_TRACE);

const eventLoopDelay = enabled ? monitorEventLoopDelay({ resolution: 10 }) : undefined;

const logEnabled = isTruthyEnvValue(process.env.OPENCLAW_GATEWAY_STARTUP_TRACE);

const timelineEnabled = isDiagnosticsTimelineEnabled();

const eventLoopTimelineEnabled =

timelineEnabled && isTruthyEnvValue(process.env.OPENCLAW_DIAGNOSTICS_EVENT_LOOP);

const eventLoopDelay =

logEnabled || eventLoopTimelineEnabled ? monitorEventLoopDelay({ resolution: 10 }) : undefined;

eventLoopDelay?.enable();

const started = performance.now();

let last = started;

let spanSequence = 0;

const formatMetric = (key: string, value: number | string) =>

`${key}=${typeof value === "number" ? value.toFixed(1) : value}`;

const readEventLoopMaxMs = () => {

const mapTimelineName = (name: string) => {

switch (name) {

case "config.snapshot":

return "config.load";

case "config.auth":

case "config.final-snapshot":

case "runtime.config":

return "config.normalize";

case "plugins.bootstrap":

return "plugins.load";

case "runtime.post-attach":

case "ready":

return "gateway.ready";

default:

return name;

}

};

const takeEventLoopSample = () => {

if (!eventLoopDelay) {

return 0;

return undefined;

}

const maxMs = eventLoopDelay.max / 1_000_000;

const sample = {

p50Ms: eventLoopDelay.percentile(50) / 1_000_000,

p95Ms: eventLoopDelay.percentile(95) / 1_000_000,

p99Ms: eventLoopDelay.percentile(99) / 1_000_000,

maxMs: eventLoopDelay.max / 1_000_000,

};

eventLoopDelay.reset();

return maxMs;

return sample;

};

const emitEventLoopTimelineSample = (

activeSpanName: string,

sample: ReturnType<typeof takeEventLoopSample>,

) => {

if (!eventLoopTimelineEnabled) {

return;

}

if (!sample) {

return;

}

emitDiagnosticsTimelineEvent({

type: "eventLoop.sample",

name: "eventLoop",

phase: "startup",

activeSpanName: mapTimelineName(activeSpanName),

attributes:

activeSpanName === mapTimelineName(activeSpanName)

? undefined

: { traceName: activeSpanName },

...sample,

});

};

const emit = (

name: string,

durationMs: number,

totalMs: number,

eventLoopSample: ReturnType<typeof takeEventLoopSample>,

extras: ReadonlyArray<readonly [string, number | string]> = [],

) => {

if (enabled) {

if (logEnabled) {

const metrics = [

`eventLoopMax=${readEventLoopMaxMs().toFixed(1)}ms`,

`eventLoopMax=${(eventLoopSample?.maxMs ?? 0).toFixed(1)}ms`,

...extras.map(([key, value]) => formatMetric(key, value)),

].join(" ");

log.info(

return {

mark(name: string) {

const now = performance.now();

emit(name, now - last, now - started);

const eventLoopSample = takeEventLoopSample();

emit(name, now - last, now - started, eventLoopSample);

emitDiagnosticsTimelineEvent({

type: "mark",

name: mapTimelineName(name),

phase: "startup",

durationMs: now - started,

attributes: name === mapTimelineName(name) ? undefined : { traceName: name },

});

emitEventLoopTimelineSample(name, eventLoopSample);

last = now;

if (name === "ready") {

eventLoopDelay?.disable();

}

},

detail(name: string, metrics: ReadonlyArray<readonly [string, number | string]>) {

if (!enabled) {

return;

const attributes = Object.fromEntries(metrics);

if (logEnabled) {

log.info(

`startup trace: ${name} ${metrics.map(([key, value]) => formatMetric(key, value)).join(" ")}`,

);

}

log.info(

`startup trace: ${name} ${metrics.map(([key, value]) => formatMetric(key, value)).join(" ")}`,

);

emitDiagnosticsTimelineEvent({

type: "mark",

name: mapTimelineName(name),

phase: "startup",

attributes: {

traceName: name,

...attributes,

},

});

},

async measure<T>(name: string, run: () => Promise<T> | T): Promise<T> {

const before = performance.now();

const spanId = `gateway-startup-${++spanSequence}`;

emitDiagnosticsTimelineEvent({

type: "span.start",

name: mapTimelineName(name),

phase: "startup",

spanId,

attributes: name === mapTimelineName(name) ? undefined : { traceName: name },

});

try {

return await run();

const result = await run();

const now = performance.now();

emitDiagnosticsTimelineEvent({

type: "span.end",

name: mapTimelineName(name),

phase: "startup",

spanId,

durationMs: now - before,

attributes: name === mapTimelineName(name) ? undefined : { traceName: name },

});

return result;

} catch (error) {

const now = performance.now();

emitDiagnosticsTimelineEvent({

type: "span.error",

name: mapTimelineName(name),

phase: "startup",

spanId,

durationMs: now - before,

attributes: name === mapTimelineName(name) ? undefined : { traceName: name },

errorName: error instanceof Error ? error.name : typeof error,

errorMessage: error instanceof Error ? error.message : String(error),

});

throw error;

} finally {

const now = performance.now();

emit(name, now - before, now - started);

const eventLoopSample = takeEventLoopSample();

emit(name, now - before, now - started, eventLoopSample);

emitEventLoopTimelineSample(name, eventLoopSample);

last = now;

}

},