miravo 0.4.0 → 0.6.0

package/src/commands/start/events.ts

@@ -0,0 +1,126 @@
+import type { Engine } from "@miravo/core";
+import { colors } from "consola/utils";
+import { printSummaryLine } from "../../lib/shutdown.ts";
+import { engineLog, faultLog, lifecycleLog } from "../../logger.ts";
+
+/**
+ * Shorten a full instance ID path to the last two segments for terminal output.
+ * E.g. "area-1/line-2/pump-003" → "line-2/pump-003".
+ * Full IDs can be 40+ chars with deep area/line/twin hierarchies.
+ */
+function shortId(instanceId: string): string {
+  const parts = instanceId.split("/");
+  return parts.length > 2 ? parts.slice(-2).join("/") : instanceId;
+}
+
+// ---------------------------------------------------------------------------
+// Step 7: Event subscriptions + periodic summary
+// ---------------------------------------------------------------------------
+
+const MAX_ERROR_CONTEXT_KEYS = 256;
+const ERROR_CONTEXT_OVERFLOW = "__overflow__";
+
+export function subscribeToEvents(
+  engine: Engine,
+  errorContextCounts: Map<string, number>,
+): () => void {
+  const onLifecycle = (event: {
+    instanceId: string;
+    from: string;
+    to: string;
+    operatingHours: number;
+  }): void => {
+    lifecycleLog.info(
+      `${shortId(event.instanceId)} ${event.from} ${colors.dim("\u2192")} ${event.to} ${colors.gray(`(${event.operatingHours.toFixed(0)}h)`)}`,
+    );
+  };
+
+  const onFaultTriggered = (event: { instanceId: string; fault: string }): void => {
+    faultLog.warn(`${shortId(event.instanceId)} ${colors.bold(event.fault)} triggered`);
+  };
+
+  const onFaultCleared = (event: { instanceId: string; fault: string }): void => {
+    faultLog.info(`${shortId(event.instanceId)} ${colors.dim(event.fault)} cleared`);
+  };
+
+  const onWarn = (event: { message: string; context: string }): void => {
+    engineLog.debug(event.message, { context: event.context });
+  };
+
+  const onReset = (event: {
+    instanceCount: number;
+    templateRunCount: number;
+    clearPersistence: boolean;
+  }): void => {
+    const suffix = event.clearPersistence ? " · saved state cleared" : "";
+    engineLog.info(
+      `simulation reset · ${colors.bold(String(event.instanceCount))} instances · ${colors.bold(String(event.templateRunCount))} template runs${suffix}`,
+    );
+  };
+
+  const onError = (event: { context: string; error: Error }): void => {
+    incrementErrorContextCount(errorContextCounts, event.context);
+    engineLog.error(event.error.message, { context: event.context }, event.error);
+  };
+
+  const onStateChanged = (event: {
+    from: "idle" | "running" | "paused" | "stopped";
+    to: "idle" | "running" | "paused" | "stopped";
+  }): void => {
+    if (event.to === "paused") {
+      engineLog.info(`simulation paused`);
+    } else if (event.to === "running" && event.from === "paused") {
+      engineLog.info(`simulation resumed`);
+    }
+  };
+
+  engine.bus.on("lifecycle:changed", onLifecycle);
+  engine.bus.on("fault:triggered", onFaultTriggered);
+  engine.bus.on("fault:cleared", onFaultCleared);
+  engine.bus.on("engine:warn", onWarn);
+  engine.bus.on("engine:error", onError);
+  engine.bus.on("engine:reset", onReset);
+  engine.bus.on("engine:state-changed", onStateChanged);
+
+  return () => {
+    engine.bus.off("lifecycle:changed", onLifecycle);
+    engine.bus.off("fault:triggered", onFaultTriggered);
+    engine.bus.off("fault:cleared", onFaultCleared);
+    engine.bus.off("engine:warn", onWarn);
+    engine.bus.off("engine:error", onError);
+    engine.bus.off("engine:reset", onReset);
+    engine.bus.off("engine:state-changed", onStateChanged);
+  };
+}
+
+export function normalizeErrorContext(raw: string): string {
+  return raw
+    .replace(/tick=\d+/g, "tick=*")
+    .replace(/instance="[^"]+"/g, 'instance="*"')
+    .replace(/model="[^"]+"/g, 'model="*"');
+}
+
+export function incrementErrorContextCount(counts: Map<string, number>, rawContext: string): void {
+  const normalizedContext = normalizeErrorContext(rawContext);
+  if (counts.has(normalizedContext)) {
+    counts.set(normalizedContext, (counts.get(normalizedContext) ?? 0) + 1);
+    return;
+  }
+
+  if (counts.size < MAX_ERROR_CONTEXT_KEYS) {
+    counts.set(normalizedContext, 1);
+    return;
+  }
+
+  counts.set(ERROR_CONTEXT_OVERFLOW, (counts.get(ERROR_CONTEXT_OVERFLOW) ?? 0) + 1);
+}
+
+export function startPeriodicSummary(
+  engine: Engine,
+  intervalSeconds: number,
+): ReturnType<typeof setInterval> {
+  return setInterval(() => {
+    const metrics = engine.getMetrics();
+    printSummaryLine(metrics);
+  }, intervalSeconds * 1_000);
+}