Add the ability to handle errors at the task and project level

Author: ericallam

apps/webapp/app/components/primitives/TreeView/TreeView.tsx

@@ -1,25 +1,9 @@
 import { VirtualItem, Virtualizer, useVirtualizer } from "@tanstack/react-virtual";
-import {
-  Fragment,
-  MutableRefObject,
-  RefObject,
-  useCallback,
-  useEffect,
-  useImperativeHandle,
-  useReducer,
-  useRef,
-  useState,
-} from "react";
+import { MutableRefObject, RefObject, useCallback, useEffect, useReducer, useRef } from "react";
 import { UnmountClosed } from "react-collapse";
 import { cn } from "~/utils/cn";
-import { Changes, NodeState, NodesState, reducer } from "./reducer";
-import {
-  applyFilterToState,
-  concreteStateFromInput,
-  firstVisibleNode,
-  lastVisibleNode,
-  selectedIdFromState,
-} from "./utils";
+import { NodeState, NodesState, reducer } from "./reducer";
+import { applyFilterToState, concreteStateFromInput, selectedIdFromState } from "./utils";
 
 export type TreeViewProps<TData> = {
   tree: FlatTree<TData>;
@@ -232,6 +216,7 @@ export function useTree<TData>({
         index,
       });
     },
+    overscan: 20,
   });
 
   const scrollToNodeFn = useCallback(

apps/webapp/app/consts.ts

@@ -10,3 +10,4 @@ export const RUN_CHUNK_EXECUTION_BUFFER = 350;
 export const MAX_RUN_CHUNK_EXECUTION_LIMIT = 120000; // 2 minutes
 export const VERCEL_RESPONSE_TIMEOUT_STATUS_CODES = [408, 504];
 export const MAX_BATCH_TRIGGER_ITEMS = 100;
+export const MAX_TASK_RUN_ATTEMPTS = 250;

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

@@ -1,12 +1,10 @@
 import { Attributes } from "@opentelemetry/api";
 import {
-  RetryOptions,
   TaskRunContext,
   TaskRunExecution,
   TaskRunExecutionResult,
   TaskRunFailedExecutionResult,
   TaskRunSuccessfulExecutionResult,
-  defaultRetryOptions,
   flattenAttributes,
 } from "@trigger.dev/core/v3";
 import { PrismaClientOrTransaction } from "~/db.server";
@@ -16,8 +14,9 @@ import { safeJsonParse } from "~/utils/json";
 import { eventRepository } from "../eventRepository.server";
 import { marqs } from "../marqs.server";
 import { BaseService } from "./baseService.server";
-import { ResumeTaskRunDependenciesService } from "./resumeTaskRunDependencies.server";
 import { CancelAttemptService } from "./cancelAttempt.server";
+import { ResumeTaskRunDependenciesService } from "./resumeTaskRunDependencies.server";
+import { MAX_TASK_RUN_ATTEMPTS } from "~/consts";
 
 type FoundAttempt = Awaited<ReturnType<typeof findAttempt>>;
 
@@ -125,48 +124,31 @@ export class CompleteAttemptService extends BaseService {
       },
     });
 
-    if (completion.retry !== undefined) {
-      const retryConfig = taskRunAttempt.backgroundWorkerTask.retryConfig
-        ? {
-            ...defaultRetryOptions,
-            ...RetryOptions.parse(taskRunAttempt.backgroundWorkerTask.retryConfig),
-          }
-        : undefined;
-
+    if (completion.retry !== undefined && taskRunAttempt.number < MAX_TASK_RUN_ATTEMPTS) {
       const environment = env ?? (await this.#getEnvironment(execution.environment.id));
 
       const retryAt = new Date(completion.retry.timestamp);
 
       // Retry the task run
-      await eventRepository.recordEvent(
-        retryConfig?.maxAttempts
-          ? `Retry ${execution.attempt.number}/${retryConfig?.maxAttempts - 1} delay`
-          : `Retry #${execution.attempt.number} delay`,
-        {
-          taskSlug: taskRunAttempt.taskRun.taskIdentifier,
-          environment,
-          attributes: {
-            metadata: this.#generateMetadataAttributesForNextAttempt(execution),
-            properties: {
-              retryAt: retryAt.toISOString(),
-              factor: retryConfig?.factor,
-              maxAttempts: retryConfig?.maxAttempts,
-              minTimeoutInMs: retryConfig?.minTimeoutInMs,
-              maxTimeoutInMs: retryConfig?.maxTimeoutInMs,
-              randomize: retryConfig?.randomize,
-            },
-            runId: taskRunAttempt.taskRunId,
-            style: {
-              icon: "schedule-attempt",
-            },
-            queueId: taskRunAttempt.queueId,
-            queueName: taskRunAttempt.taskRun.queue,
+      await eventRepository.recordEvent(`Retry #${execution.attempt.number} delay`, {
+        taskSlug: taskRunAttempt.taskRun.taskIdentifier,
+        environment,
+        attributes: {
+          metadata: this.#generateMetadataAttributesForNextAttempt(execution),
+          properties: {
+            retryAt: retryAt.toISOString(),
           },
-          context: taskRunAttempt.taskRun.traceContext as Record<string, string | undefined>,
-          spanIdSeed: `retry-${taskRunAttempt.number + 1}`,
-          endTime: retryAt,
-        }
-      );
+          runId: taskRunAttempt.taskRunId,
+          style: {
+            icon: "schedule-attempt",
+          },
+          queueId: taskRunAttempt.queueId,
+          queueName: taskRunAttempt.taskRun.queue,
+        },
+        context: taskRunAttempt.taskRun.traceContext as Record<string, string | undefined>,
+        spanIdSeed: `retry-${taskRunAttempt.number + 1}`,
+        endTime: retryAt,
+      });
 
       logger.debug("Retrying", { taskRun: taskRunAttempt.taskRun.friendlyId });
 

packages/cli-v3/src/commands/dev.tsx

@@ -138,7 +138,7 @@ async function startDev(
         if (config.status === "file") {
           logger.log(`${basename(config.path)} changed...`);
           logger.debug("New config", { config: config.config });
-          rerender(await getDevReactElement(config.config, authorization));
+          rerender(await getDevReactElement(config.config, authorization, config.path));
         } else {
           logger.debug("New config", { config: config.config });
           rerender(await getDevReactElement(config.config, authorization));
@@ -148,7 +148,8 @@ async function startDev(
 
     async function getDevReactElement(
       configParam: ResolvedConfig,
-      authorization: { apiUrl: string; accessToken: string }
+      authorization: { apiUrl: string; accessToken: string },
+      configPath?: string
     ) {
       const accessToken = authorization.accessToken;
       const apiUrl = authorization.apiUrl;
@@ -175,11 +176,18 @@ async function startDev(
           projectName={devEnv.data.name}
           debuggerOn={options.debugger}
           debugOtel={options.debugOtel}
+          configPath={configPath}
         />
       );
     }
 
-    const devReactElement = render(await getDevReactElement(config.config, authorization));
+    const devReactElement = render(
+      await getDevReactElement(
+        config.config,
+        authorization,
+        config.status === "file" ? config.path : undefined
+      )
+    );
 
     rerender = devReactElement.rerender;
 
@@ -205,6 +213,7 @@ type DevProps = {
   projectName: string;
   debuggerOn: boolean;
   debugOtel: boolean;
+  configPath?: string;
 };
 
 function useDev({
@@ -215,6 +224,7 @@ function useDev({
   projectName,
   debuggerOn,
   debugOtel,
+  configPath,
 }: DevProps) {
   useEffect(() => {
     const websocketUrl = new URL(apiUrl);
@@ -334,10 +344,24 @@ function useDev({
         importResolve("./workers/dev/worker-setup.js", import.meta.url)
       ).href.replace("file://", "");
 
-      const entryPointContents = workerFacade
+      let entryPointContents = workerFacade
         .replace("__TASKS__", createTaskFileImports(taskFiles))
         .replace("__WORKER_SETUP__", `import { tracingSDK, sender } from "${workerSetupPath}";`);
 
+      if (configPath) {
+        logger.debug("Importing project config from", { configPath });
+
+        entryPointContents = entryPointContents.replace(
+          "__IMPORTED_PROJECT_CONFIG__",
+          `import importedConfig from "${configPath}";`
+        );
+      } else {
+        entryPointContents = entryPointContents.replace(
+          "__IMPORTED_PROJECT_CONFIG__",
+          `const importedConfig = undefined;`
+        );
+      }
+
       let firstBuild = true;
 
       logger.log(chalk.dim("⎔ Building background worker..."));

packages/cli-v3/src/types.ts

@@ -1,11 +1,24 @@
-import { TaskMetadataWithFilePath } from "@trigger.dev/core/v3";
+import {
+  HandleErrorFnParams,
+  HandleErrorResult,
+  InitFnParams,
+  InitOutput,
+  MiddlewareFnParams,
+  RunFnParams,
+  TaskMetadataWithFilePath,
+} from "@trigger.dev/core/v3";
 
 export type TaskMetadataWithFunctions = TaskMetadataWithFilePath & {
   fns: {
-    run: (payload: any, params: any) => Promise<any>;
-    init?: (payload: any, params: any) => Promise<void>;
-    cleanup?: (payload: any, params: any) => Promise<void>;
-    middleware?: (payload: any, params: any) => Promise<void>;
+    run: (payload: any, params: RunFnParams<any>) => Promise<any>;
+    init?: (payload: any, params: InitFnParams) => Promise<InitOutput>;
+    cleanup?: (payload: any, params: RunFnParams<any>) => Promise<void>;
+    middleware?: (payload: any, params: MiddlewareFnParams) => Promise<void>;
+    handleError?: (
+      payload: any,
+      error: unknown,
+      params: HandleErrorFnParams<any>
+    ) => HandleErrorResult;
   };
 };
 

packages/cli-v3/src/workers/dev/backgroundWorker.ts

@@ -366,9 +366,9 @@ export class BackgroundWorker {
       const taskRunProcess = new TaskRunProcess(
         this.path,
         {
-          ...this.#readEnvVars(),
           ...this.params.env,
           ...(payload.environment ?? {}),
+          ...this.#readEnvVars(),
         },
         this.metadata,
         this.params