refactor(webapp): resolve region<->backing from WorkerInstanceGroup.region, drop env map

nicktrn · nicktrn · commit 697de0378a31 · 2026-06-15T21:05:30.000+01:00
diff --git a/apps/webapp/app/env.server.ts b/apps/webapp/app/env.server.ts
@@ -158,10 +158,6 @@ const EnvironmentSchema = z
     WORKER_SCHEMA: z.string().default("graphile_worker"),
     WORKER_CONCURRENCY: z.coerce.number().int().default(10),
     WORKER_POLL_INTERVAL: z.coerce.number().int().default(1000),
-    // JSON map of container-region masterQueue -> compute-backing masterQueue.
-    // Absence of an entry means that region is never migrated (e.g. EU until it
-    // has a compute backing). Example: {"us-east-1":"us-east-1-next"}
-    COMPUTE_BACKING_MAP: z.string().default("{}"),
     // How often each replica reloads the global flags snapshot from the DB.
     // Sets kill/ramp propagation latency.
     GLOBAL_FLAGS_RELOAD_INTERVAL_MS: z.coerce.number().int().min(1000).default(5000),
diff --git a/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts
@@ -16,8 +16,7 @@ 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 { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import {
   findRunByIdWithMollifierFallback,
@@ -523,7 +522,7 @@ async function createCommonRunStructure(run: CommonRelatedRun, apiVersion: API_V
     batchId: run.batch?.friendlyId,
     metadata,
     region: run.workerQueue
-      ? regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap)
+      ? regionForQueue(baseWorkerQueue(run.workerQueue), workerRegionRegistry.current() ?? [])
       : undefined,
   };
 }
diff --git a/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts b/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts
@@ -12,8 +12,7 @@ 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 { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { isCancellableRunStatus, isFinalRunStatus, isPendingRunStatus } from "~/v3/taskStatus";
@@ -263,7 +262,7 @@ export class NextRunListPresenter {
             type: run.queue.startsWith("task/") ? "task" : "custom",
           },
           region: run.workerQueue
-            ? regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap)
+            ? regionForQueue(baseWorkerQueue(run.workerQueue), workerRegionRegistry.current() ?? [])
             : undefined,
           taskKind: RunAnnotations.safeParse(run.annotations).data?.taskKind ?? "STANDARD",
         };
diff --git a/apps/webapp/app/presenters/v3/SpanPresenter.server.ts b/apps/webapp/app/presenters/v3/SpanPresenter.server.ts
@@ -16,8 +16,7 @@ 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 { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { logger } from "~/services/logger.server";
 import { rehydrateAttribute } from "~/v3/eventRepository/eventRepository.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
@@ -305,7 +304,7 @@ export class SpanPresenter extends BasePresenter {
           location: true,
         },
         where: {
-          masterQueue: regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap),
+          masterQueue: regionForQueue(baseWorkerQueue(run.workerQueue), workerRegionRegistry.current() ?? []),
         },
       });
 
diff --git a/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts b/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts
@@ -19,8 +19,7 @@ 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 { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
 import { queueTypeFromType } from "~/presenters/v3/QueueRetrievePresenter.server";
 import { ReplayRunData } from "~/v3/replayTask";
@@ -215,7 +214,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     region:
       environment.type === "DEVELOPMENT"
         ? undefined
-        : regionForBacking(baseWorkerQueue(run.workerQueue), computeBackingMap),
+        : regionForQueue(baseWorkerQueue(run.workerQueue), workerRegionRegistry.current() ?? []),
     regions: regionsResult.regions,
     ttlSeconds: run.ttl ? parseDuration(run.ttl, "s") ?? undefined : undefined,
     idempotencyKey: run.idempotencyKey,
diff --git a/apps/webapp/app/runEngine/concerns/computeMigration.server.ts b/apps/webapp/app/runEngine/concerns/computeMigration.server.ts
@@ -7,40 +7,6 @@ export type ComputeMigrationFlags = {
   computeMigrationPaidPercentage?: number;
 };
 
-export type ComputeBackingMap = Record<string, string>;
-
-/**
- * Parse COMPUTE_BACKING_MAP (container-region masterQueue -> compute-backing
- * masterQueue). Never throws: bad JSON or non-string values yield {} so a
- * misconfigured env disables migration rather than breaking triggers.
- */
-export function parseComputeBackingMap(raw: string): ComputeBackingMap {
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null) return {};
-    const out: ComputeBackingMap = {};
-    for (const [k, v] of Object.entries(parsed)) {
-      if (typeof v === "string") out[k] = v;
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-/**
- * 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;
@@ -81,7 +47,7 @@ export function isOrgMigrated({
 type ResolveInput = MigrationDecisionInput & {
   baseWorkerQueue: string | undefined;
   envType: string;
-  backingMap: ComputeBackingMap;
+  backing: string | undefined; // the compute backing for this queue's region, or undefined
 };
 
 /**
@@ -93,11 +59,11 @@ type ResolveInput = MigrationDecisionInput & {
 export function resolveComputeMigration({
   baseWorkerQueue,
   envType,
-  backingMap,
+  backing,
   ...decision
 }: ResolveInput): string | undefined {
   if (baseWorkerQueue === undefined) return baseWorkerQueue;
   if (envType === "DEVELOPMENT") return baseWorkerQueue;
   if (!isOrgMigrated(decision)) return baseWorkerQueue;
-  return backingMap[baseWorkerQueue] ?? baseWorkerQueue;
+  return backing ?? baseWorkerQueue;
 }
diff --git a/apps/webapp/app/runEngine/services/triggerTask.server.ts b/apps/webapp/app/runEngine/services/triggerTask.server.ts
@@ -39,7 +39,7 @@ import {
   workerQueueForRun,
 } from "../concerns/workerQueueSplit.server";
 import { resolveComputeMigration } from "../concerns/computeMigration.server";
-import { computeBackingMap } from "~/v3/computeBackingMap.server";
+import { workerRegionRegistry, backingForQueue } from "~/v3/workerRegions.server";
 import { globalFlagsRegistry } from "~/v3/globalFlagsRegistry.server";
 import {
   publishClaim as publishMollifierClaim,
@@ -368,14 +368,18 @@ export class RunEngineTriggerTaskService {
           if (!globalFlagsRegistry.isLoaded) {
             await globalFlagsRegistry.waitUntilReady(env.GLOBAL_FLAGS_READY_TIMEOUT_MS);
           }
+          if (!workerRegionRegistry.isLoaded) {
+            await workerRegionRegistry.waitUntilReady(env.GLOBAL_FLAGS_READY_TIMEOUT_MS);
+          }
+          const workerGroups = workerRegionRegistry.current() ?? [];
           const migratedWorkerQueue = resolveComputeMigration({
             baseWorkerQueue,
             planType,
             orgId: environment.organization.id,
             orgFeatureFlags: environment.organization.featureFlags as Record<string, unknown> | null,
             flags: globalFlagsRegistry.current(),
             envType: environment.type,
-            backingMap: computeBackingMap,
+            backing: baseWorkerQueue ? backingForQueue(baseWorkerQueue, workerGroups) : undefined,
           });
 
           // Build annotations for this run
diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts
@@ -39,8 +39,7 @@ import pLimit from "p-limit";
 import { detectBadJsonStrings } from "~/utils/detectBadJsonStrings";
 import { calculateErrorFingerprint } from "~/utils/errorFingerprinting";
 import { baseWorkerQueue } from "~/runEngine/concerns/workerQueueSplit.server";
-import { regionForBacking } from "~/runEngine/concerns/computeMigration.server";
-import { computeBackingMap } from "~/v3/computeBackingMap.server";
+import { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import {
   isClickHouseJsonParseError,
   parseRowNumberFromError,
@@ -1124,7 +1123,7 @@ export class RunsReplicationService {
       event === "delete" ? 1 : 0, // _is_deleted
       run.concurrencyKey ?? "", // concurrency_key
       run.bulkActionGroupIds ?? [], // bulk_action_group_ids
-      regionForBacking(baseWorkerQueue(run.masterQueue ?? ""), computeBackingMap), // worker_queue (geo region; strip `:scheduled` and hide the compute backing - customers query this column)
+      regionForQueue(baseWorkerQueue(run.masterQueue ?? ""), workerRegionRegistry.current() ?? []), // worker_queue (geo region; strip `:scheduled` and hide the compute backing - customers query this column)
       run.maxDurationInSeconds ?? null, // max_duration_in_seconds
       annotations?.triggerSource ?? "", // trigger_source
       annotations?.rootTriggerSource ?? "", // root_trigger_source
diff --git a/apps/webapp/app/v3/computeBackingMap.server.ts b/apps/webapp/app/v3/computeBackingMap.server.ts
diff --git a/apps/webapp/app/v3/services/computeTemplateCreation.server.ts b/apps/webapp/app/v3/services/computeTemplateCreation.server.ts
@@ -9,7 +9,8 @@ import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { ServiceValidationError } from "./baseService.server";
 import { FailDeploymentService } from "./failDeployment.server";
 import { resolveComputeAccess } from "../regionAccess.server";
-import { isOrgMigrated, parseComputeBackingMap } from "~/runEngine/concerns/computeMigration.server";
+import { isOrgMigrated } from "~/runEngine/concerns/computeMigration.server";
+import { backingForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { globalFlagsRegistry } from "~/v3/globalFlagsRegistry.server";
 import { getEntitlement } from "~/services/platform.v3.server";
 
@@ -167,9 +168,11 @@ export class ComputeTemplateCreationService {
     // Migrated orgs route runs to the compute backing even though their stored
     // default is still the container region, so they need a compute template too.
     // shadow mode: never fail a deploy over a backing the org didn't opt into.
-    const backingMap = parseComputeBackingMap(env.COMPUTE_BACKING_MAP);
+    if (!workerRegionRegistry.isLoaded) {
+      await workerRegionRegistry.waitUntilReady(env.GLOBAL_FLAGS_READY_TIMEOUT_MS);
+    }
     const defaultQueue = project.defaultWorkerGroup?.masterQueue;
-    if (defaultQueue && backingMap[defaultQueue]) {
+    if (defaultQueue && backingForQueue(defaultQueue, workerRegionRegistry.current() ?? [])) {
       const planType = (await getEntitlement(project.organization.id))?.plan?.type;
       if (!globalFlagsRegistry.isLoaded) {
         await globalFlagsRegistry.waitUntilReady(env.GLOBAL_FLAGS_READY_TIMEOUT_MS);
diff --git a/apps/webapp/app/v3/services/replayTaskRun.server.ts b/apps/webapp/app/v3/services/replayTaskRun.server.ts
@@ -7,8 +7,7 @@ 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 { regionForQueue, workerRegionRegistry } from "~/v3/workerRegions.server";
 import { logger } from "~/services/logger.server";
 import { BaseService } from "./baseService.server";
 import { OutOfEntitlementError, TriggerTaskService } from "./triggerTask.server";
@@ -71,7 +70,7 @@ export class ReplayTaskRunService extends BaseService {
     const region = ignoreRegion
       ? undefined
       : overrideOptions.region ??
-        regionForBacking(baseWorkerQueue(existingTaskRun.workerQueue), computeBackingMap);
+        regionForQueue(baseWorkerQueue(existingTaskRun.workerQueue), workerRegionRegistry.current() ?? []);
 
     try {
       const taskQueue = await this._prisma.taskQueue.findFirst({
diff --git a/apps/webapp/app/v3/workerRegions.server.ts b/apps/webapp/app/v3/workerRegions.server.ts
@@ -45,8 +45,8 @@ export function backingForQueue(queue: string, groups: WorkerGroupRegionRow[]):
 /**
  * In-memory snapshot of every worker group's (queue, region, type, hidden),
  * refreshed on an interval. Read synchronously on the hot path; callers gate the
- * first read on `waitUntilReady`. Replaces the COMPUTE_BACKING_MAP env var as the
- * source of truth for region<->backing resolution.
+ * first read on `waitUntilReady`. DB-backed source of truth for region<->backing
+ * resolution (replaces the old env-var backing map).
  */
 export const workerRegionRegistry = singleton("workerRegionRegistry", () =>
   createReloadingRegistry<WorkerGroupRegionRow[]>({
diff --git a/apps/webapp/test/computeMigration.test.ts b/apps/webapp/test/computeMigration.test.ts
@@ -1,25 +1,9 @@
 import { describe, it, expect } from "vitest";
 import {
-  parseComputeBackingMap,
   isOrgMigrated,
   resolveComputeMigration,
-  regionForBacking,
 } from "~/runEngine/concerns/computeMigration.server";
 
-const BACKING = { "us-east-1": "us-east-1-next" };
-
-describe("parseComputeBackingMap", () => {
-  it("parses valid JSON", () => {
-    expect(parseComputeBackingMap('{"us-east-1":"us-east-1-next"}')).toEqual(BACKING);
-  });
-  it("returns {} on invalid JSON without throwing", () => {
-    expect(parseComputeBackingMap("not json")).toEqual({});
-  });
-  it("returns {} on non-string values", () => {
-    expect(parseComputeBackingMap('{"us-east-1":5}')).toEqual({});
-  });
-});
-
 describe("isOrgMigrated", () => {
   const base = {
     planType: "free" as string | undefined,
@@ -83,42 +67,20 @@ describe("resolveComputeMigration", () => {
     orgFeatureFlags: {},
     flags: { computeMigrationEnabled: true, computeMigrationFreePercentage: 100 },
     envType: "PRODUCTION",
-    backingMap: BACKING,
   };
-
   it("swaps to the compute backing for an enrolled free org", () => {
-    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x" }))
-      .toBe("us-east-1-next");
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", backing: "us-east-1-next" })).toBe("us-east-1-next");
   });
-  it("leaves a region with no backing untouched (EU)", () => {
-    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "eu-central-1", orgId: "org_x" }))
-      .toBe("eu-central-1");
+  it("leaves the queue unchanged when there is no backing for the region (EU)", () => {
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "eu-central-1", orgId: "org_x", backing: undefined })).toBe("eu-central-1");
   });
   it("does not migrate DEVELOPMENT", () => {
-    expect(
-      resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", envType: "DEVELOPMENT" })
-    ).toBe("us-east-1");
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", backing: "us-east-1-next", envType: "DEVELOPMENT" })).toBe("us-east-1");
   });
   it("leaves a non-enrolled org untouched", () => {
-    expect(
-      resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", flags: { computeMigrationEnabled: false } })
-    ).toBe("us-east-1");
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", backing: "us-east-1-next", flags: { computeMigrationEnabled: false } })).toBe("us-east-1");
   });
   it("undefined baseWorkerQueue passes through", () => {
-    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: undefined, orgId: "org_x" }))
-      .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");
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: undefined, orgId: "org_x", backing: "us-east-1-next" })).toBeUndefined();
   });
 });
