fix(execution): honor retryable-failure suppression for unavailable admission

The new admission-infrastructure log row ignored suppressRetryableFailureLogs,
so a webhook with a setup retry still available recorded a terminal failure
before the same execution was requeued. That option exists precisely for this
shape: statusCode >= 500 and retryable, which RESERVATION_INFRASTRUCTURE (503,
retryable) matches. The denial branch nearby is unaffected because its
descriptors are 402/429.

Builds the failure once and reuses it for both the suppression check and the
returned error rather than duplicating the shape.

Author: waleedlatif1

apps/sim/lib/execution/preprocessing.test.ts

@@ -62,6 +62,7 @@ vi.mock('@/lib/core/rate-limiter/rate-limiter', () => ({
 }))
 vi.mock('@/lib/logs/execution/logging-session', () => loggingSessionMock)
 
+import { UsageReservationUnavailableError } from '@/lib/billing/calculations/usage-reservation'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { preprocessExecution, WORKFLOW_NOT_DEPLOYED_CODE } from './preprocessing'
 
@@ -289,6 +290,38 @@ describe('preprocessExecution suppressRetryableFailureLogs option', () => {
     expect(loggingSession.safeStart).not.toHaveBeenCalled()
   })
 
+  it('skips the failure row when admission infrastructure is unavailable and a retry remains', async () => {
+    mockReserveExecutionSlot.mockRejectedValueOnce(
+      new UsageReservationUnavailableError('Usage admission is temporarily unavailable.')
+    )
+    const loggingSession = makeLoggingSession()
+
+    const result = await preprocessExecution({
+      ...baseOptions,
+      suppressRetryableFailureLogs: true,
+      loggingSession: loggingSession as any,
+    })
+
+    expect(result).toMatchObject({ success: false, error: { statusCode: 503, retryable: true } })
+    expect(loggingSession.safeStart).not.toHaveBeenCalled()
+  })
+
+  it('records the failure row for an unavailable admission when no retry remains', async () => {
+    mockReserveExecutionSlot.mockRejectedValueOnce(
+      new UsageReservationUnavailableError('Usage admission is temporarily unavailable.')
+    )
+    const loggingSession = makeLoggingSession()
+
+    const result = await preprocessExecution({
+      ...baseOptions,
+      suppressRetryableFailureLogs: false,
+      loggingSession: loggingSession as any,
+    })
+
+    expect(result).toMatchObject({ success: false, error: { statusCode: 503, retryable: true } })
+    expect(loggingSession.safeStart).toHaveBeenCalled()
+  })
+
   it('still records non-retryable failures while suppression is on', async () => {
     workflowAuthzMockFns.mockGetActiveWorkflowRecord.mockRejectedValueOnce(
       new Error('column "unknown" does not exist')

apps/sim/lib/execution/preprocessing.ts

@@ -822,32 +822,38 @@ export async function preprocessExecution(
        * admission infrastructure was unreachable left no execution log at all,
        * so it disappeared from the workspace's logs rather than showing as a
        * failure — the denial branch twenty lines up always recorded one.
+       *
+       * Unlike that branch, this one has to honor the suppression: its denial
+       * descriptors are 402/429, while this failure is 503 and retryable, which
+       * is precisely what a requeuing caller defers. Recording here regardless
+       * would write a terminal failure for an execution about to be retried.
        */
-      await recordPreprocessingError({
-        workflowId,
-        executionId,
-        triggerType,
-        requestId,
-        userId: actorUserId,
-        workspaceId,
-        errorMessage: unavailable.message,
-        loggingSession: providedLoggingSession,
-        triggerData,
-      })
-
-      return {
-        success: false,
-        error: {
-          message: unavailable.message,
-          statusCode: unavailable.statusCode,
+      const unavailableFailure: PreprocessExecutionError = {
+        message: unavailable.message,
+        statusCode: unavailable.statusCode,
+        code: unavailable.code,
+        retryable: unavailable.retryable,
+        ...retryAfterMsFrom(unavailable.retryAfterSeconds),
+        cause: {
           code: unavailable.code,
-          retryable: unavailable.retryable,
-          ...retryAfterMsFrom(unavailable.retryAfterSeconds),
-          cause: {
-            code: unavailable.code,
-          },
         },
       }
+
+      if (!isFailureLogSuppressed(unavailableFailure)) {
+        await recordPreprocessingError({
+          workflowId,
+          executionId,
+          triggerType,
+          requestId,
+          userId: actorUserId,
+          workspaceId,
+          errorMessage: unavailable.message,
+          loggingSession: providedLoggingSession,
+          triggerData,
+        })
+      }
+
+      return { success: false, error: unavailableFailure }
     }
   }