@powerhousedao/switchboard 6.2.3-dev.42 → 6.2.3-dev.44

package/dist/server.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as resolveUnsupportedStoredDocuments, i as StoredDocumentsRefusedError, n as isPortAvailable, o as applySwitchboardReactorDefaults, r as startSwitchboard, t as deriveAttachmentServiceConfig } from "./server-CMAxYG6D.mjs";
+import { a as resolveUnsupportedStoredDocuments, i as StoredDocumentsRefusedError, n as isPortAvailable, o as applySwitchboardReactorDefaults, r as startSwitchboard, t as deriveAttachmentServiceConfig } from "./server-Bk_IZzCn.mjs";
 export { StoredDocumentsRefusedError, applySwitchboardReactorDefaults, deriveAttachmentServiceConfig, isPortAvailable, resolveUnsupportedStoredDocuments, startSwitchboard };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a4c8ff4a-a754-5a57-860f-5cadf1712728")}catch(e){}}();
-//# debugId=a4c8ff4a-a754-5a57-860f-5cadf1712728
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="72238471-a760-5883-8f43-7ff4b6802a34")}catch(e){}}();
+//# debugId=72238471-a760-5883-8f43-7ff4b6802a34

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/switchboard",
   "type": "module",
-  "version": "6.2.3-dev.42",
+  "version": "6.2.3-dev.44",
   "main": "dist/index.mjs",
   "exports": {
     ".": {
@@ -41,7 +41,7 @@
     "@openfeature/core": "1.9.1",
     "@openfeature/env-var-provider": "0.3.1",
     "@openfeature/server-sdk": "1.19.0",
-    "@powerhousedao/config": "6.2.3-dev.42",
+    "@powerhousedao/config": "6.2.3-dev.44",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
@@ -55,23 +55,23 @@
     "@opentelemetry/sdk-node": "^0.218.0",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@opentelemetry/semantic-conventions": "^1.41.1",
-    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.42",
-    "@powerhousedao/reactor": "6.2.3-dev.42",
-    "@powerhousedao/shared": "6.2.3-dev.42",
-    "@powerhousedao/vetra": "6.2.3-dev.42",
-    "@powerhousedao/reactor-api": "6.2.3-dev.42",
-    "@powerhousedao/reactor-attachments": "6.2.3-dev.42",
-    "@powerhousedao/reactor-drive": "6.2.3-dev.42",
-    "@powerhousedao/reactor-group": "6.2.3-dev.42",
-    "@powerhousedao/reactor-privacy": "6.2.3-dev.42",
-    "@powerhousedao/reactor-workflow": "6.2.3-dev.42",
-    "@powerhousedao/workflow": "6.2.3-dev.42",
-    "@powerhousedao/pglite-fs": "6.2.3-dev.42",
+    "@powerhousedao/opentelemetry-instrumentation-reactor": "6.2.3-dev.44",
+    "@powerhousedao/reactor": "6.2.3-dev.44",
+    "@powerhousedao/shared": "6.2.3-dev.44",
+    "@powerhousedao/vetra": "6.2.3-dev.44",
+    "@powerhousedao/reactor-api": "6.2.3-dev.44",
+    "@powerhousedao/reactor-attachments": "6.2.3-dev.44",
+    "@powerhousedao/reactor-drive": "6.2.3-dev.44",
+    "@powerhousedao/reactor-group": "6.2.3-dev.44",
+    "@powerhousedao/reactor-privacy": "6.2.3-dev.44",
+    "@powerhousedao/reactor-workflow": "6.2.3-dev.44",
+    "@powerhousedao/workflow": "6.2.3-dev.44",
+    "@powerhousedao/pglite-fs": "6.2.3-dev.44",
     "@pyroscope/nodejs": "^0.4.5",
-    "@renown/sdk": "6.2.3-dev.42",
+    "@renown/sdk": "6.2.3-dev.44",
     "@sentry/node": "^10.53.1",
     "@sentry/opentelemetry": "^10.53.1",
-    "document-model": "6.2.3-dev.42",
+    "document-model": "6.2.3-dev.44",
     "dotenv": "^16.4.7",
     "express": "^4.22.1",
     "graphql": "^16",

package/test/fatal-shutdown.test.ts

@@ -94,6 +94,39 @@ describe("installFatalErrorShutdown", () => {
     expect(proc.exit).not.toHaveBeenCalled();
   });
 
+  it("still reaches exit when the logger itself throws EPIPE inside onFatal", () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    const onSigterm = vi.fn();
+    proc.on("SIGTERM", onSigterm);
+    const error = vi.fn(() => {
+      throw Object.assign(new Error("write EPIPE"), { code: "EPIPE" });
+    });
+    const throwingLogger = { error } as unknown as Parameters<
+      typeof installFatalErrorShutdown
+    >[0];
+    installFatalErrorShutdown(throwingLogger, proc as never);
+
+    // Without the guard the EPIPE propagates out of the uncaughtException
+    // listener, which in a real process re-enters fatal handling instead of
+    // running the shutdown.
+    expect(() =>
+      proc.emit("uncaughtException", new Error("boom")),
+    ).not.toThrow();
+
+    expect(proc.kill).toHaveBeenCalledOnce();
+    expect(onSigterm).toHaveBeenCalledOnce();
+    expect(proc.exitCode).toBe(1);
+
+    vi.advanceTimersByTime(15_000);
+
+    expect(proc.exit).toHaveBeenCalledTimes(1);
+    expect(proc.exit).toHaveBeenCalledWith(1);
+    // Exactly the two guarded log attempts: the fatal report and the
+    // forced-exit notice. A re-entered handler would log again.
+    expect(error).toHaveBeenCalledTimes(2);
+  });
+
   it("routes a triggered fatal error through SIGTERM with exit code 1", () => {
     const proc = makeProc();
     const onSigterm = vi.fn();

package/test/observability-signals.test.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from "node:events";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { installFatalErrorShutdown } from "../src/fatal-shutdown.mjs";
+import { installObservabilitySignalHandlers } from "../src/observability-signals.mjs";
+
+function makeProc() {
+  const emitter = new EventEmitter();
+  const proc = Object.assign(emitter, {
+    pid: 1234,
+    exitCode: undefined as number | undefined,
+    kill: vi.fn((_pid: number, signal: string) => {
+      emitter.emit(signal);
+      return true;
+    }),
+    exit: vi.fn(),
+  });
+  return proc;
+}
+
+const logger = {
+  error: vi.fn(),
+} as unknown as Parameters<typeof installFatalErrorShutdown>[0];
+
+/** Lets the finally callback behind the flush promise run. */
+async function settleMicrotasks(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe("installObservabilitySignalHandlers", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it.each(["SIGINT", "SIGTERM"])(
+    "exits 0 after the flush on an ordinary %s",
+    async (signal) => {
+      const proc = makeProc();
+      const flush = vi.fn(() => Promise.resolve());
+      installObservabilitySignalHandlers(flush, proc as never);
+
+      proc.emit(signal);
+      await settleMicrotasks();
+
+      expect(flush).toHaveBeenCalledOnce();
+      expect(proc.exit).toHaveBeenCalledExactlyOnceWith(0);
+    },
+  );
+
+  it("does not exit before the flush settles", async () => {
+    const proc = makeProc();
+    let finish: () => void = () => undefined;
+    const flush = vi.fn(
+      () => new Promise<void>((resolve) => (finish = resolve)),
+    );
+    installObservabilitySignalHandlers(flush, proc as never);
+
+    proc.emit("SIGTERM");
+    await settleMicrotasks();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    finish();
+    await settleMicrotasks();
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(0);
+  });
+
+  it("keeps exit code 1 when a fatal error raised the SIGTERM", async () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    const flush = vi.fn(() => Promise.resolve());
+    // Production order: observability's handlers install at module load,
+    // before the fatal handlers.
+    installObservabilitySignalHandlers(flush, proc as never);
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("uncaughtException", new Error("boom"));
+    expect(proc.exitCode).toBe(1);
+    await settleMicrotasks();
+
+    // The flush ran, but observability never lowered the code to 0; the
+    // process is still alive inside the fatal path's drain budget.
+    expect(flush).toHaveBeenCalledOnce();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    // Fatal-shutdown's backstop owns the exit and preserves code 1.
+    vi.advanceTimersByTime(15_000);
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(1);
+    expect(proc.exit).not.toHaveBeenCalledWith(0);
+    expect(proc.exitCode).toBe(1);
+  });
+
+  it("leaves the fatal drain budget intact even when the flush is slow", async () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    let finish: () => void = () => undefined;
+    const flush = vi.fn(
+      () => new Promise<void>((resolve) => (finish = resolve)),
+    );
+    installObservabilitySignalHandlers(flush, proc as never);
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("uncaughtException", new Error("boom"));
+
+    // The flush gives up at its own ~5s budget (simulated by resolving it
+    // here); that settling must not force an exit ahead of the drain.
+    vi.advanceTimersByTime(5_000);
+    finish();
+    await settleMicrotasks();
+    expect(proc.exit).not.toHaveBeenCalled();
+
+    // Only the 15s fatal backstop ends the process, with code 1.
+    vi.advanceTimersByTime(9_999);
+    expect(proc.exit).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1);
+    expect(proc.exit).toHaveBeenCalledExactlyOnceWith(1);
+  });
+
+  it("respects a non-zero exit code set by any other module", async () => {
+    const proc = makeProc();
+    proc.exitCode = 1;
+    const flush = vi.fn(() => Promise.resolve());
+    installObservabilitySignalHandlers(flush, proc as never);
+
+    proc.emit("SIGTERM");
+    await settleMicrotasks();
+
+    expect(flush).toHaveBeenCalledOnce();
+    expect(proc.exit).not.toHaveBeenCalled();
+  });
+});