fix(webapp): address CodeRabbit review on the task metadata cache

- TaskMetadataCache: interface → type alias, matching the repo's
  'prefer type unless extending' standard.
- syncTaskMetadataCache calls in createBackgroundWorker,
  createDeploymentBackgroundWorkerV3, and createDeploymentBackgroundWorkerV4
  are now wrapped in tryCatch and log on failure. Matches the pattern in
  changeCurrentDeployment so a Redis blip can't strand a successful worker
  build or deploy promotion.
- Back-fill assertion in 'cache miss falls through to PG' now polls with a
  bounded timeout instead of a fixed sleep, removing the CI flake surface.
- Promotion assertion in 'ChangeCurrentDeploymentService promotes the env
  cache' now pre-clears the by-worker + env keys and asserts they're null
  before the call, so the test proves the service did the write.

Author: ericallam

apps/webapp/app/services/taskMetadataCache.server.ts

@@ -10,7 +10,7 @@ export type TaskMetadataEntry = {
   queueName: string;
 };
 
-export interface TaskMetadataCache {
+export type TaskMetadataCache = {
   getCurrent(envId: string, slug: string): Promise<TaskMetadataEntry | null>;
   getByWorker(workerId: string, slug: string): Promise<TaskMetadataEntry | null>;
   populateCurrent(envId: string, entries: TaskMetadataEntry[]): Promise<void>;
@@ -20,7 +20,7 @@ export interface TaskMetadataCache {
   /** Add a single field to the by-worker keyspace and refresh the hash TTL. */
   setByWorker(workerId: string, entry: TaskMetadataEntry): Promise<void>;
   invalidateCurrent(envId: string): Promise<void>;
-}
+};
 
 export type RedisTaskMetadataCacheOptions = {
   redis: Redis;

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

@@ -234,14 +234,26 @@ export class CreateBackgroundWorkerService extends BaseService {
       // worker by createdAt. Non-DEV (deploy-built) workers are not promoted
       // here — promotion writes the `:env:` keyspace later in
       // changeCurrentDeployment / createDeploymentBackgroundWorkerV3.
+      // Wrap in tryCatch so a Redis blip can't break the post-cache side
+      // effects below.
       if (workerTaskEntries && workerTaskEntries.length > 0) {
-        await syncTaskMetadataCache(
-          environment.id,
-          backgroundWorker.id,
-          environment.type === "DEVELOPMENT",
-          workerTaskEntries,
-          this._taskMetaCache
+        const [metaCacheError] = await tryCatch(
+          syncTaskMetadataCache(
+            environment.id,
+            backgroundWorker.id,
+            environment.type === "DEVELOPMENT",
+            workerTaskEntries,
+            this._taskMetaCache
+          )
         );
+
+        if (metaCacheError) {
+          logger.error("Error syncing task metadata cache", {
+            error: metaCacheError,
+            backgroundWorker,
+            environment,
+          });
+        }
       }
 
       const [updateConcurrencyLimitsError] = await tryCatch(

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

@@ -168,15 +168,27 @@ export class CreateDeploymentBackgroundWorkerServiceV3 extends BaseService {
       }
 
       // V3 promotes the deployment immediately above, so this worker is now
-      // current for the env — write both keyspaces.
+      // current for the env — write both keyspaces. Wrap in tryCatch so a
+      // Redis blip can't strand the post-cache side effects below (waiting
+      // runs flush, alerts, timeout cancellation).
       if (workerTaskEntries.length > 0) {
-        await syncTaskMetadataCache(
-          environment.id,
-          backgroundWorker.id,
-          true,
-          workerTaskEntries,
-          this._taskMetaCache
+        const [metaCacheError] = await tryCatch(
+          syncTaskMetadataCache(
+            environment.id,
+            backgroundWorker.id,
+            true,
+            workerTaskEntries,
+            this._taskMetaCache
+          )
         );
+
+        if (metaCacheError) {
+          logger.error("Error syncing task metadata cache on deployment", {
+            error: metaCacheError,
+            deploymentId: deployment.id,
+            workerId: backgroundWorker.id,
+          });
+        }
       }
 
       try {

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

@@ -152,14 +152,27 @@ export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
       // only the `task-meta:by-worker:{workerId}` keyspace so locked-version
       // triggers against this build hit the cache. Promotion (which writes the
       // env keyspace) happens later via finalizeDeployment → changeCurrentDeployment.
+      // Wrap in tryCatch so a Redis blip can't break the deployment state
+      // machine — without this the build would stall in BUILDING and only
+      // surface as a misleading "Indexing timed out".
       if (workerTaskEntries && workerTaskEntries.length > 0) {
-        await syncTaskMetadataCache(
-          environment.id,
-          backgroundWorker.id,
-          false,
-          workerTaskEntries,
-          this._taskMetaCache
+        const [metaCacheError] = await tryCatch(
+          syncTaskMetadataCache(
+            environment.id,
+            backgroundWorker.id,
+            false,
+            workerTaskEntries,
+            this._taskMetaCache
+          )
         );
+
+        if (metaCacheError) {
+          logger.error("Error syncing task metadata cache on build", {
+            error: metaCacheError,
+            deploymentId: deployment.id,
+            workerId: backgroundWorker.id,
+          });
+        }
       }
 
       const [schedulesError] = await tryCatch(

apps/webapp/test/engine/triggerTask.test.ts

@@ -1294,10 +1294,12 @@ describe("DefaultQueueManager task metadata cache", () => {
       assertNonNullable(result);
       expect((result.run.annotations as { taskKind?: string } | null)?.taskKind).toBe("STANDARD");
 
-      // Back-fill is fire-and-forget; allow a turn of the event loop for it to land.
-      await setTimeout(50);
-
-      const backfilled = await cache.getCurrent(environment.id, taskIdentifier);
+      // Back-fill is fire-and-forget; poll with a bounded timeout to avoid CI flakes.
+      let backfilled = await cache.getCurrent(environment.id, taskIdentifier);
+      for (let i = 0; i < 40 && !backfilled; i++) {
+        await setTimeout(25);
+        backfilled = await cache.getCurrent(environment.id, taskIdentifier);
+      }
       expect(backfilled).not.toBeNull();
       expect(backfilled?.triggerSource).toBe("STANDARD");
       expect(backfilled?.queueName).toBe(`task/${taskIdentifier}`);
@@ -1495,14 +1497,22 @@ describe("DefaultQueueManager task metadata cache", () => {
       const redis = new Redis(redisOptions);
       const cache = new RedisTaskMetadataCache({ redis });
 
+      // Pre-clear any pre-existing cache state so the assertions below prove
+      // the rollback service did the write — not some other path. The test
+      // helpers don't currently populate the cache, but pre-clearing keeps the
+      // test bulletproof against future helper changes.
+      await redis.del(`task-meta:by-worker:${workerA.worker.id}`);
+      await redis.del(`task-meta:env:${environment.id}`);
+      expect(await cache.getByWorker(workerA.worker.id, taskIdentifier)).toBeNull();
+      expect(await cache.getCurrent(environment.id, taskIdentifier)).toBeNull();
+
       // Manually rollback to A to exercise the cache-write side effect.
       const service = new ChangeCurrentDeploymentService(prisma, undefined, cache);
       await service.call(workerA.deployment, "rollback", true /* disableVersionCheck */);
 
-      // Allow the awaited cache write to settle.
+      // Both keyspaces should now reflect workerA.
       const entry = await cache.getCurrent(environment.id, taskIdentifier);
       expect(entry).not.toBeNull();
-      // by-worker keyspace also written by syncTaskMetadataCache(isCurrent=true)
       const byWorkerEntry = await cache.getByWorker(workerA.worker.id, taskIdentifier);
       expect(byWorkerEntry).not.toBeNull();
       expect(byWorkerEntry?.queueName).toBe(`task/${taskIdentifier}`);