hubErrorHandler: report unhandled route errors through reportError

The global onError handler only called log.error and returned a 500/422
body, so an unhandled route exception left no refId a user could quote
back to support. It now reports through @corbits/error-sink's
reportError (operation, tenantId when a tenant-scoped route set one,
and path/method as extra) and includes the returned refId in both the
generic 500 body and the guidance-error 422 body.

Fixes CL-7132.

Author: TheGreatAxios

apps/hub/src/hub-error-handler.ts

@@ -5,10 +5,10 @@
 // workflow's launch body failing to read, a definition asset that never
 // materialized — stays invisible until someone reports it from the UI.
 // This handler is the one place every such exception is guaranteed to be
-// logged, and it maps a named consumer-facing error to a real 4xx rather
+// reported, and it maps a named consumer-facing error to a real 4xx rather
 // than folding it into a generic message.
 import type { Context } from "hono";
-import { getLogger } from "@intx/log";
+import { reportError } from "@corbits/error-sink";
 
 /**
  * Duck-typed rather than an `instanceof` allowlist: any error carrying a
@@ -28,24 +28,39 @@ function hasGuidance(err: unknown): err is Error & { guidance: string } {
 }
 
 /**
- * Builds the handler passed to `app.onError`. Takes the logger as a
- * parameter (rather than constructing one internally) so a test can
- * inject a fake and assert on what got logged.
+ * `app.onError` runs for routes mounted both inside and outside the
+ * platform's tenant middleware, so `c`'s `Variables` aren't statically
+ * known here; this narrows just enough to read `tenant.id` when a
+ * tenant-scoped route set it, without claiming the wider type.
  */
-export function hubErrorHandler(log: ReturnType<typeof getLogger>) {
+function extractTenantId(c: Context): string | undefined {
+  return (c as unknown as Context<{ Variables: { tenant?: { id: string } } }>)
+    .var.tenant?.id;
+}
+
+/** Builds the handler passed to `app.onError`. */
+export function hubErrorHandler() {
   return (err: unknown, c: Context): Response | Promise<Response> => {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error`Unhandled error on ${c.req.method} ${c.req.path}: ${message}`;
+    const tenantId = extractTenantId(c);
+    const refId = reportError(err, {
+      operation: "hub.unhandled_route_error",
+      ...(tenantId !== undefined ? { tenantId } : {}),
+      extra: { path: c.req.path, method: c.req.method },
+    });
 
     if (hasGuidance(err)) {
-      return c.json({ error: { code: err.name, message: err.message } }, 422);
+      return c.json(
+        { error: { code: err.name, message: err.message, refId } },
+        422,
+      );
     }
 
     return c.json(
       {
         error: {
           code: "internal_error",
           message: "Something went wrong. Please try again.",
+          refId,
         },
       },
       500,

apps/hub/src/index.ts

@@ -1100,8 +1100,8 @@ export async function createHub(config: HubConfig) {
 
   // Without this, any exception escaping a route (extension or platform
   // alike) falls through to Hono's built-in handler: a bare 500 with
-  // nothing logged. See `hubErrorHandler`'s own doc comment.
-  app.onError(hubErrorHandler(getLogger(["hub", "error"])));
+  // nothing reported. See `hubErrorHandler`'s own doc comment.
+  app.onError(hubErrorHandler());
 
   // Extension routes mount under the tenant prefix, inside the
   // platform's native tenant middleware, so every extension handler