fix(webapp): hide compute backing on read surfaces and fix replay

Author: nicktrn

apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts

@@ -16,6 +16,8 @@ import assertNever from "assert-never";
 import { API_VERSIONS, CURRENT_API_VERSION, RunStatusUnspecifiedApiVersion } from "~/api/versions";
 import { $replica, prisma } from "~/db.server";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
+import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import {
   findRunByIdWithMollifierFallback,
@@ -520,7 +522,9 @@ async function createCommonRunStructure(run: CommonRelatedRun, apiVersion: API_V
     triggerFunction: resolveTriggerFunction(run),
     batchId: run.batch?.friendlyId,
     metadata,
-    region: run.workerQueue ? baseWorkerQueue(run.workerQueue) : undefined,
+    region: run.workerQueue
+      ? regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap)
+      : undefined,
   };
 }
 

apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts

@@ -12,6 +12,8 @@ import { findDisplayableEnvironment } from "~/models/runtimeEnvironment.server";
 import { getTaskIdentifiers } from "~/models/task.server";
 import { RunsRepository } from "~/services/runsRepository/runsRepository.server";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
+import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { isCancellableRunStatus, isFinalRunStatus, isPendingRunStatus } from "~/v3/taskStatus";
@@ -260,7 +262,9 @@ export class NextRunListPresenter {
             name: run.queue.replace("task/", ""),
             type: run.queue.startsWith("task/") ? "task" : "custom",
           },
-          region: run.workerQueue ? baseWorkerQueue(run.workerQueue) : undefined,
+          region: run.workerQueue
+            ? regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap)
+            : undefined,
           taskKind: RunAnnotations.safeParse(run.annotations).data?.taskKind ?? "STANDARD",
         };
       }),

apps/webapp/app/presenters/v3/SpanPresenter.server.ts

@@ -16,6 +16,8 @@ import {
 } from "@trigger.dev/core/v3/serverOnly";
 import { RUNNING_STATUSES } from "~/components/runs/v3/TaskRunStatus";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
+import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { logger } from "~/services/logger.server";
 import { rehydrateAttribute } from "~/v3/eventRepository/eventRepository.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
@@ -303,7 +305,7 @@ export class SpanPresenter extends BasePresenter {
           location: true,
         },
         where: {
-          masterQueue: baseWorkerQueue(run.workerQueue),
+          masterQueue: regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap),
         },
       });
 

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

@@ -19,6 +19,8 @@ import {
 } from "~/v3/mollifier/syntheticReplayTaskRun.server";
 import parseDuration from "parse-duration";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
+import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
 import { queueTypeFromType } from "~/presenters/v3/QueueRetrievePresenter.server";
 import { ReplayRunData } from "~/v3/replayTask";
@@ -210,7 +212,10 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     maxAttempts: run.maxAttempts,
     maxDurationSeconds: run.maxDurationInSeconds,
     machinePreset: run.machinePreset,
-    region: environment.type === "DEVELOPMENT" ? undefined : baseWorkerQueue(run.workerQueue),
+    region:
+      environment.type === "DEVELOPMENT"
+        ? undefined
+        : regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap),
     regions: regionsResult.regions,
     ttlSeconds: run.ttl ? parseDuration(run.ttl, "s") ?? undefined : undefined,
     idempotencyKey: run.idempotencyKey,

apps/webapp/app/runEngine/concerns/computeMigration.server.ts

@@ -28,6 +28,19 @@ export function parseComputeBackingMap(raw: string): ComputeBackingMap {
   }
 }
 
+/**
+ * Inverse of the backing map: given a worker queue, return the user-facing geo
+ * region. If the queue is a compute backing (a *value* in the map), return the
+ * region it backs; otherwise return the queue unchanged. Used to hide the
+ * backing on customer surfaces and to re-derive the region on replay.
+ */
+export function regionForBacking(queue: string, backingMap: ComputeBackingMap): string {
+  for (const [region, backing] of Object.entries(backingMap)) {
+    if (backing === queue) return region;
+  }
+  return queue;
+}
+
 type MigrationDecisionInput = {
   planType: string | undefined;
   orgId: string;

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -38,10 +38,8 @@ import {
   resolveScheduledQueueSplitEnabled,
   workerQueueForRun,
 } from "../concerns/workerQueueSplit.server";
-import {
-  parseComputeBackingMap,
-  resolveComputeMigration,
-} from "../concerns/computeMigration.server";
+import { resolveComputeMigration } from "../concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { globalFlagsRegistry } from "~/v3/globalFlagsRegistry.server";
 import {
   publishClaim as publishMollifierClaim,
@@ -70,8 +68,6 @@ import { mollifyTrigger } from "~/v3/mollifier/mollifierMollify.server";
 import { type MollifierBuffer } from "@trigger.dev/redis-worker";
 import { QueueSizeLimitExceededError, ServiceValidationError } from "~/v3/services/common.server";
 
-const COMPUTE_BACKING_MAP = parseComputeBackingMap(env.COMPUTE_BACKING_MAP);
-
 class NoopTriggerRacepointSystem implements TriggerRacepointSystem {
   async waitForRacepoint(options: { racepoint: TriggerRacepoints; id: string }): Promise<void> {
     return;
@@ -379,7 +375,7 @@ export class RunEngineTriggerTaskService {
             orgFeatureFlags: environment.organization.featureFlags as Record<string, unknown> | null,
             flags: globalFlagsRegistry.current(),
             envType: environment.type,
-            backingMap: COMPUTE_BACKING_MAP,
+            backingMap: computeBackingMap,
           });
 
           // Build annotations for this run

apps/webapp/app/v3/computeBackingMap.server.ts

@@ -0,0 +1,5 @@
+import { env } from "~/env.server";
+import { parseComputeBackingMap } from "~/runEngine/concerns/computeMigration.server";
+
+/** Parsed once: region -> compute-backing worker queue. Operator env, rarely changes. */
+export const computeBackingMap = parseComputeBackingMap(env.COMPUTE_BACKING_MAP);

apps/webapp/app/v3/services/replayTaskRun.server.ts

@@ -7,6 +7,8 @@ import {
 import { type TaskRun } from "@trigger.dev/database";
 import { findEnvironmentById } from "~/models/runtimeEnvironment.server";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
+import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
+import { computeBackingMap } from "~/v3/computeBackingMap.server";
 import { logger } from "~/services/logger.server";
 import { BaseService } from "./baseService.server";
 import { OutOfEntitlementError, TriggerTaskService } from "./triggerTask.server";
@@ -68,7 +70,8 @@ export class ReplayTaskRunService extends BaseService {
       authenticatedEnvironment.type === "DEVELOPMENT";
     const region = ignoreRegion
       ? undefined
-      : overrideOptions.region ?? baseWorkerQueue(existingTaskRun.workerQueue);
+      : overrideOptions.region ??
+        regionForBacking(baseWorkerQueue(existingTaskRun.workerQueue), computeBackingMap);
 
     try {
       const taskQueue = await this._prisma.taskQueue.findFirst({

apps/webapp/test/computeMigration.test.ts

@@ -3,6 +3,7 @@ import {
   parseComputeBackingMap,
   isOrgMigrated,
   resolveComputeMigration,
+  regionForBacking,
 } from "~/runEngine/concerns/computeMigration.server";
 
 const BACKING = { "us-east-1": "us-east-1-next" };
@@ -108,3 +109,16 @@ describe("resolveComputeMigration", () => {
       .toBeUndefined();
   });
 });
+
+describe("regionForBacking", () => {
+  it("maps a backing to its region", () => {
+    expect(regionForBacking("us-east-1-next", BACKING)).toBe("us-east-1");
+  });
+  it("passes a non-backing queue through unchanged", () => {
+    expect(regionForBacking("us-east-1", BACKING)).toBe("us-east-1");
+    expect(regionForBacking("eu-central-1", BACKING)).toBe("eu-central-1");
+  });
+  it("passes through unchanged with an empty map", () => {
+    expect(regionForBacking("us-east-1-next", {})).toBe("us-east-1-next");
+  });
+});