fix(webapp,run-store): make the unroutable-id fallback actually catch, and count only routed traffic

Two defects from review of the previous commit.

undefinedOnUnroutableId took the read as a promise, but RoutingRunStore.findRun is
not async and resolves the shard before it returns anything, so an unroutable id threw
while the argument was still being evaluated and never reached the try block. Every
dashboard and resource route it was added to still answered a server error. It now
takes a thunk, and a test covers the synchronous-throw case that types cannot.

runops_shard_routed_total counted every call through the generic store lookup, which
probes, fan-outs and fallback legs also use, so an unrouted miss credited legacy and a
waitpoint home-miss counted twice. Counting moved to the two id-routed entry points, so
the series means what its name says. Tests cover an unrouted miss and a probe leg.

Author: d-cs

apps/webapp/app/routes/@.runs.$runParam.ts

@@ -35,18 +35,19 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   }
 
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      {
-        friendlyId: runParam,
-      },
-      {
-        select: {
-          spanId: true,
-          runtimeEnvironmentId: true,
+    () =>
+      runStore.findRun(
+        {
+          friendlyId: runParam,
+        },
+        {
+          select: {
+            spanId: true,
+            runtimeEnvironmentId: true,
+          },
         },
-      },
-      prisma
-    ),
+        prisma
+      ),
     { runParam: params.runParam ?? params.runId }
   );
 

apps/webapp/app/routes/orgs.$organizationSlug.projects.$projectParam.runs.$runParam.ts

@@ -17,17 +17,18 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const { organizationSlug, projectParam, runParam } = ParamSchema.parse(params);
 
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      {
-        friendlyId: runParam,
-      },
-      {
-        select: {
-          projectId: true,
-          runtimeEnvironmentId: true,
+    () =>
+      runStore.findRun(
+        {
+          friendlyId: runParam,
         },
-      }
-    ),
+        {
+          select: {
+            projectId: true,
+            runtimeEnvironmentId: true,
+          },
+        }
+      ),
     { runParam: params.runParam ?? params.runId }
   );
 

apps/webapp/app/routes/projects.v3.$projectRef.runs.$runParam.ts

@@ -38,19 +38,20 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   }
 
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      {
-        friendlyId: validatedParams.runParam,
-      },
-      {
-        select: {
-          friendlyId: true,
-          spanId: true,
-          runtimeEnvironmentId: true,
+    () =>
+      runStore.findRun(
+        {
+          friendlyId: validatedParams.runParam,
         },
-      },
-      prisma
-    ),
+        {
+          select: {
+            friendlyId: true,
+            spanId: true,
+            runtimeEnvironmentId: true,
+          },
+        },
+        prisma
+      ),
     { runParam: params.runParam ?? params.runId }
   );
 

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.realtime.v1.sessions.$sessionId.$io.ts

@@ -62,10 +62,10 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   // Replica lag can null out a live run; a spurious 404 breaks the dashboard Agent tab subscription
   // (useRealtimeStream surfaces the error and does not auto-retry). Re-read the primary on a miss.
   const run =
-    (await undefinedOnUnroutableId(runStore.findRun(runWhere, runArgs, $replica), {
+    (await undefinedOnUnroutableId(() => runStore.findRun(runWhere, runArgs, $replica), {
       runParam: params.runParam,
     })) ??
-    (await undefinedOnUnroutableId(runStore.findRunOnPrimary(runWhere, runArgs), {
+    (await undefinedOnUnroutableId(() => runStore.findRunOnPrimary(runWhere, runArgs), {
       runParam: params.runParam,
     }));
 

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.realtime.v1.streams.$runId.$streamId.ts

@@ -61,10 +61,10 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   // Replica lag can null out a live run; a spurious 404 breaks the dashboard Agent tab subscription
   // (useRealtimeStream surfaces the error and does not auto-retry). Re-read the primary on a miss.
   const run =
-    (await undefinedOnUnroutableId(runStore.findRun(runWhere, runArgs, $replica), {
+    (await undefinedOnUnroutableId(() => runStore.findRun(runWhere, runArgs, $replica), {
       runParam: params.runParam,
     })) ??
-    (await undefinedOnUnroutableId(runStore.findRunOnPrimary(runWhere, runArgs), {
+    (await undefinedOnUnroutableId(() => runStore.findRunOnPrimary(runWhere, runArgs), {
       runParam: params.runParam,
     }));
 

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.realtime.v1.streams.$runId.input.$streamId.ts

@@ -63,10 +63,10 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   // Replica lag can null out a live run; a spurious 404 breaks the dashboard Agent tab input-stream
   // subscription (useRealtimeStream surfaces the error, no auto-retry). Re-read the primary on a miss.
   const run =
-    (await undefinedOnUnroutableId(runStore.findRun(runWhere, runArgs, $replica), {
+    (await undefinedOnUnroutableId(() => runStore.findRun(runWhere, runArgs, $replica), {
       runParam: params.runParam,
     })) ??
-    (await undefinedOnUnroutableId(runStore.findRunOnPrimary(runWhere, runArgs), {
+    (await undefinedOnUnroutableId(() => runStore.findRunOnPrimary(runWhere, runArgs), {
       runParam: params.runParam,
     }));
 

apps/webapp/app/routes/resources.runs.$runParam.logs.download.ts

@@ -33,21 +33,22 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   // membership is a control-plane concern resolved separately below — joining it here is a
   // cross-DB join that returns nothing once the run lives in run-ops.
   let run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      { friendlyId: parsedParams.runParam },
-      {
-        select: {
-          friendlyId: true,
-          traceId: true,
-          organizationId: true,
-          runtimeEnvironmentId: true,
-          createdAt: true,
-          completedAt: true,
-          taskEventStore: true,
-          taskIdentifier: true,
-        },
-      }
-    ),
+    () =>
+      runStore.findRun(
+        { friendlyId: parsedParams.runParam },
+        {
+          select: {
+            friendlyId: true,
+            traceId: true,
+            organizationId: true,
+            runtimeEnvironmentId: true,
+            createdAt: true,
+            completedAt: true,
+            taskEventStore: true,
+            taskIdentifier: true,
+          },
+        }
+      ),
     { runParam: parsedParams.runParam }
   );
 

apps/webapp/app/routes/resources.runs.$runParam.ts

@@ -20,67 +20,68 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const parsedParams = v3RunParamsSchema.pick({ runParam: true }).parse(params);
 
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      {
-        friendlyId: parsedParams.runParam,
-      },
-      {
-        select: {
-          id: true,
-          traceId: true,
-          //metadata
-          number: true,
-          taskIdentifier: true,
-          friendlyId: true,
-          isTest: true,
-          runTags: true,
-          machinePreset: true,
-          runtimeEnvironmentId: true,
-          projectId: true,
-          lockedById: true,
-          lockedToVersionId: true,
-          //status + duration
-          status: true,
-          startedAt: true,
-          createdAt: true,
-          updatedAt: true,
-          queuedAt: true,
-          completedAt: true,
-          logsDeletedAt: true,
-          //idempotency
-          idempotencyKey: true,
-          //delayed
-          delayUntil: true,
-          //ttl
-          ttl: true,
-          expiredAt: true,
-          //queue
-          queue: true,
-          concurrencyKey: true,
-          //schedule
-          scheduleId: true,
-          //usage
-          baseCostInCents: true,
-          costInCents: true,
-          usageDurationMs: true,
-          payload: true,
-          payloadType: true,
-          metadata: true,
-          metadataType: true,
-          maxAttempts: true,
-          parentTaskRun: {
-            select: {
-              friendlyId: true,
+    () =>
+      runStore.findRun(
+        {
+          friendlyId: parsedParams.runParam,
+        },
+        {
+          select: {
+            id: true,
+            traceId: true,
+            //metadata
+            number: true,
+            taskIdentifier: true,
+            friendlyId: true,
+            isTest: true,
+            runTags: true,
+            machinePreset: true,
+            runtimeEnvironmentId: true,
+            projectId: true,
+            lockedById: true,
+            lockedToVersionId: true,
+            //status + duration
+            status: true,
+            startedAt: true,
+            createdAt: true,
+            updatedAt: true,
+            queuedAt: true,
+            completedAt: true,
+            logsDeletedAt: true,
+            //idempotency
+            idempotencyKey: true,
+            //delayed
+            delayUntil: true,
+            //ttl
+            ttl: true,
+            expiredAt: true,
+            //queue
+            queue: true,
+            concurrencyKey: true,
+            //schedule
+            scheduleId: true,
+            //usage
+            baseCostInCents: true,
+            costInCents: true,
+            usageDurationMs: true,
+            payload: true,
+            payloadType: true,
+            metadata: true,
+            metadataType: true,
+            maxAttempts: true,
+            parentTaskRun: {
+              select: {
+                friendlyId: true,
+              },
             },
-          },
-          rootTaskRun: {
-            select: {
-              friendlyId: true,
+            rootTaskRun: {
+              select: {
+                friendlyId: true,
+              },
             },
           },
-        },
-      }
-    ),
+        }
+      ),
     { runParam: params.runParam ?? params.runId }
   );
 

apps/webapp/app/routes/resources.taskruns.$runParam.debug.ts

@@ -20,21 +20,22 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   // project/org-membership auth is a control-plane concern resolved separately below —
   // joining it here is a cross-DB join that returns nothing once the run lives in run-ops.
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      { friendlyId: runParam },
-      {
-        select: {
-          id: true,
-          engine: true,
-          friendlyId: true,
-          queue: true,
-          concurrencyKey: true,
-          queueTimestamp: true,
-          runtimeEnvironmentId: true,
-          projectId: true,
-        },
-      }
-    ),
+    () =>
+      runStore.findRun(
+        { friendlyId: runParam },
+        {
+          select: {
+            id: true,
+            engine: true,
+            friendlyId: true,
+            queue: true,
+            concurrencyKey: true,
+            queueTimestamp: true,
+            runtimeEnvironmentId: true,
+            projectId: true,
+          },
+        }
+      ),
     { runParam: params.runParam ?? params.runId }
   );
 

apps/webapp/app/routes/runs.$runParam.ts

@@ -18,18 +18,19 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   const { runParam } = ParamsSchema.parse(params);
 
   const run = await undefinedOnUnroutableId(
-    runStore.findRun(
-      {
-        friendlyId: runParam,
-      },
-      {
-        select: {
-          spanId: true,
-          projectId: true,
-          runtimeEnvironmentId: true,
+    () =>
+      runStore.findRun(
+        {
+          friendlyId: runParam,
         },
-      }
-    ),
+        {
+          select: {
+            spanId: true,
+            projectId: true,
+            runtimeEnvironmentId: true,
+          },
+        }
+      ),
     { runParam: params.runParam ?? params.runId }
   );