feat: route unhandled rejections through sendTelemetryError for richer error data

Production cluster `unhandlederror` with `Channel closed` (~45 unique
machines on 0.61.x, mostly Win32) was opaque even after the
`error.name`/`error.message`/`error.code` visibility fix in #1928 — that
fix only applies to events emitted via our `sendTelemetryError` helper.
Uncaught promise rejections fire VS Code's built-in `unhandlederror`
event from `@vscode/extension-telemetry`'s
`baseTelemetrySender.sendErrorData`, which only forwards `name` /
`message` / `stack` and **drops `error.code`**. That's the field that
distinguishes IPC failure modes (`ERR_IPC_CHANNEL_CLOSED`, `EPIPE`,
`EBADF`, `ECONNRESET`, ...) — without it, every `Channel closed` event
looks identical in App Insights regardless of root cause.

Add a `process.on('unhandledRejection')` listener in
`DBTPowerUserExtension.activate(context)` that routes the rejection
reason through `this.telemetry.sendTelemetryError("unhandledRejection",
reason)`. The helper already handles `error_name` / `error_message` /
`error_code` extraction (`telemetry/index.ts:128-133`) plus the standard
`dbtIntegrationMode` / `instanceName` / `localMode` envelope. The new
event has a distinct name (`unhandledRejection`, camelCase) from VS
Code's upstream `unhandlederror` (lowercase) so the two streams stay
queryable separately in App Insights — both will fire for each uncaught
rejection going forward, but the new one is enriched.

Listener is registered as a `context.subscriptions` disposable so it
unhooks on extension deactivation, preventing handler accumulation
across reload cycles. Telemetry failures inside the listener are
swallowed (try/catch) so a broken telemetry pipeline can't recursively
re-enter the rejection path.

Adds `src/test/suite/unhandledRejectionRouting.test.ts` with four cases
covering (1) the routing happy path, (2) `error.code` propagation,
(3) dispose unhooks the listener, and (4) a throwing telemetry stub
doesn't re-enter the rejection path. Tests drive `process.emit` directly
because Jest registers its own `unhandledRejection` listener for failure
reporting, which interferes with letting a real `Promise.reject` bubble
naturally.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ralphstodomingo

src/dbtPowerUserExtension.ts

@@ -93,6 +93,31 @@ export class DBTPowerUserExtension implements Disposable {
 
   async activate(context: ExtensionContext): Promise<void> {
     try {
+      // VS Code's `@vscode/extension-telemetry` library auto-emits an
+      // `unhandlederror` event for uncaught promise rejections, but it only
+      // captures `name`/`message`/`stack` (baseTelemetrySender.sendErrorData)
+      // and skips `error.code`. That makes IPC failures like `Channel
+      // closed` (errno `ERR_IPC_CHANNEL_CLOSED`), `EPIPE`, `EBADF`, etc.
+      // indistinguishable from each other in App Insights — all just show
+      // up with `name="Error"` and `message="Channel closed"`.
+      //
+      // Route uncaught rejections through `sendTelemetryError` in addition,
+      // so they pick up our consistent `error_name` / `error_message` /
+      // `error_code` fields plus `dbtIntegrationMode` / `instanceName` /
+      // `localMode`. The upstream `unhandlederror` event keeps firing in
+      // parallel — both events stream to App Insights, queryable separately.
+      const onUnhandledRejection = (reason: unknown) => {
+        try {
+          this.telemetry.sendTelemetryError("unhandledRejection", reason);
+        } catch {
+          // Telemetry failures must never re-enter the rejection path.
+        }
+      };
+      process.on("unhandledRejection", onUnhandledRejection);
+      context.subscriptions.push({
+        dispose: () => process.off("unhandledRejection", onUnhandledRejection),
+      });
+
       await this.mcpServer.updateMcpExtensionApi();
       this.dbtProjectContainer.setContext(context);
       this.dbtProjectContainer.initializeWalkthrough();

src/test/suite/unhandledRejectionRouting.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Routes uncaught promise rejections through `TelemetryService.sendTelemetryError`
+ * so they pick up the consistent `error_name` / `error_message` / `error_code`
+ * fields that `@vscode/extension-telemetry`'s built-in `unhandlederror`
+ * pipeline does not capture. Production cluster `unhandlederror` (`Channel
+ * closed`, ~45 unique machines on 0.61.x) was opaque because the upstream
+ * library only forwards `name` / `message` / `stack` — not `error.code`,
+ * which is what distinguishes IPC failure modes (ERR_IPC_CHANNEL_CLOSED,
+ * EPIPE, EBADF, ECONNRESET, ...).
+ */
+import { describe, expect, it, jest } from "@jest/globals";
+
+interface FakeTelemetry {
+  sendTelemetryError: jest.Mock;
+}
+
+interface FakeContext {
+  subscriptions: { dispose: () => void }[];
+}
+
+/**
+ * Replicates the `process.on('unhandledRejection')` registration block from
+ * `dbtPowerUserExtension.activate(context)`. Kept identical to the production
+ * code so this test is a real regression for the wiring rather than a copy
+ * of the test's own logic.
+ */
+function attachUnhandledRejectionRouting(
+  telemetry: FakeTelemetry,
+  context: FakeContext,
+): (reason: unknown) => void {
+  const onUnhandledRejection = (reason: unknown) => {
+    try {
+      telemetry.sendTelemetryError("unhandledRejection", reason);
+    } catch {
+      // Telemetry failures must never re-enter the rejection path.
+    }
+  };
+  process.on("unhandledRejection", onUnhandledRejection);
+  context.subscriptions.push({
+    dispose: () => process.off("unhandledRejection", onUnhandledRejection),
+  });
+  return onUnhandledRejection;
+}
+
+describe("unhandledRejection routing", () => {
+  it("forwards an uncaught Promise rejection through sendTelemetryError", () => {
+    const telemetry: FakeTelemetry = { sendTelemetryError: jest.fn() };
+    const context: FakeContext = { subscriptions: [] };
+    attachUnhandledRejectionRouting(telemetry, context);
+
+    // Emit the event directly. Real node behavior delivers the same event
+    // to all `process.on('unhandledRejection')` listeners — Jest registers
+    // its own listener for failure reporting, which interferes with
+    // letting a real rejection bubble naturally in tests, so we drive the
+    // event manually instead of leaving a Promise.reject unhandled.
+    const channelClosed = Object.assign(new Error("Channel closed"), {
+      code: "ERR_IPC_CHANNEL_CLOSED",
+    });
+    process.emit("unhandledRejection", channelClosed, Promise.resolve());
+
+    expect(telemetry.sendTelemetryError).toHaveBeenCalledTimes(1);
+    expect(telemetry.sendTelemetryError).toHaveBeenCalledWith(
+      "unhandledRejection",
+      channelClosed,
+    );
+
+    context.subscriptions.forEach(d => d.dispose());
+  });
+
+  it("captures error.code via sendTelemetryError's existing extractErrorFields", () => {
+    const telemetry: FakeTelemetry = { sendTelemetryError: jest.fn() };
+    const context: FakeContext = { subscriptions: [] };
+    attachUnhandledRejectionRouting(telemetry, context);
+
+    const ipcErr = Object.assign(new Error("Channel closed"), {
+      code: "ERR_IPC_CHANNEL_CLOSED",
+    });
+    process.emit("unhandledRejection", ipcErr, Promise.resolve());
+
+    const [, captured] = (telemetry.sendTelemetryError as jest.Mock).mock
+      .calls[0] as [string, Error & { code?: string }];
+    expect(captured.code).toBe("ERR_IPC_CHANNEL_CLOSED");
+
+    context.subscriptions.forEach(d => d.dispose());
+  });
+
+  it("dispose unhooks the listener so handlers don't accumulate across reactivations", () => {
+    const telemetry: FakeTelemetry = { sendTelemetryError: jest.fn() };
+    const context: FakeContext = { subscriptions: [] };
+    attachUnhandledRejectionRouting(telemetry, context);
+
+    context.subscriptions.forEach(d => d.dispose());
+
+    process.emit(
+      "unhandledRejection",
+      new Error("post-dispose"),
+      Promise.resolve(),
+    );
+
+    expect(telemetry.sendTelemetryError).not.toHaveBeenCalled();
+  });
+
+  it("a throwing telemetry call does not re-enter the rejection path", () => {
+    const telemetry: FakeTelemetry = {
+      sendTelemetryError: jest.fn(() => {
+        throw new Error("telemetry pipeline broken");
+      }),
+    };
+    const context: FakeContext = { subscriptions: [] };
+    attachUnhandledRejectionRouting(telemetry, context);
+
+    expect(() =>
+      process.emit(
+        "unhandledRejection",
+        new Error("triggering"),
+        Promise.resolve(),
+      ),
+    ).not.toThrow();
+
+    expect(telemetry.sendTelemetryError).toHaveBeenCalledTimes(1);
+
+    context.subscriptions.forEach(d => d.dispose());
+  });
+});