@trigger.dev/core 0.0.0-v3-prerelease-20250108142426 → 0.0.0-v4-prerelease-20250916125920

package/dist/esm/v3/workers/taskExecutor.js

@@ -1,11 +1,12 @@
-import { SpanKind } from "@opentelemetry/api";
-import { VERSION } from "../../version.js";
-import { parseError, sanitizeError, TaskPayloadParsedError } from "../errors.js";
-import { runMetadata, waitUntil } from "../index.js";
+import { context, SpanKind } from "@opentelemetry/api";
+import { promiseWithResolvers } from "../../utils.js";
+import { InternalError, isCompleteTaskWithOutput, isInternalError, parseError, sanitizeError, TaskPayloadParsedError, } from "../errors.js";
+import { accessoryAttributes, attemptKey, flattenAttributes, lifecycleHooks, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, runMetadata, traceContext, waitUntil, } from "../index.js";
 import { recordSpanException } from "../otel/index.js";
-import { TaskRunContext, TaskRunErrorCodes, } from "../schemas/index.js";
+import { runTimelineMetrics } from "../run-timeline-metrics-api.js";
+import { COLD_VARIANT, TaskRunErrorCodes, WARM_VARIANT, } from "../schemas/index.js";
 import { SemanticInternalAttributes } from "../semanticInternalAttributes.js";
-import { taskContext } from "../task-context-api.js";
+import { tryCatch } from "../tryCatch.js";
 import { conditionallyExportPacket, conditionallyImportPacket, createPacketAttributes, parsePacket, stringifyIO, } from "../utils/ioSerialization.js";
 import { calculateNextRetryDelay } from "../utils/retries.js";
 export class TaskExecutor {
@@ -13,106 +14,87 @@ export class TaskExecutor {
     _tracingSDK;
     _tracer;
     _consoleInterceptor;
-    _importedConfig;
-    _handleErrorFn;
+    _retries;
+    _isWarmStart;
+    _executionCount;
     constructor(task, options) {
         this.task = task;
         this._tracingSDK = options.tracingSDK;
         this._tracer = options.tracer;
         this._consoleInterceptor = options.consoleInterceptor;
-        this._importedConfig = options.config;
-        this._handleErrorFn = options.handleErrorFn;
+        this._retries = options.retries;
+        this._isWarmStart = options.isWarmStart;
+        this._executionCount = options.executionCount;
     }
-    async execute(execution, worker, traceContext, usage, signal) {
-        const ctx = TaskRunContext.parse(execution);
+    async execute(execution, ctx, signal) {
         const attemptMessage = `Attempt ${execution.attempt.number}`;
         const originalPacket = {
             data: execution.run.payload,
             dataType: execution.run.payloadType,
         };
-        taskContext.setGlobalTaskContext({
-            ctx,
-            worker,
-        });
         if (execution.run.metadata) {
             runMetadata.enterWithMetadata(execution.run.metadata);
         }
-        this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
-            ...taskContext.attributes,
-            [SemanticInternalAttributes.SDK_VERSION]: VERSION,
-            [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript",
-        });
         const result = await this._tracer.startActiveSpan(attemptMessage, async (span) => {
+            const attemptContext = context.active();
             return await this._consoleInterceptor.intercept(console, async () => {
                 let parsedPayload;
                 let initOutput;
-                try {
+                const [inputError, payloadResult] = await tryCatch(runTimelineMetrics.measureMetric("trigger.dev/execution", "payload", async () => {
                     const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
-                    parsedPayload = await parsePacket(payloadPacket);
-                }
-                catch (inputError) {
+                    return await parsePacket(payloadPacket);
+                }));
+                if (inputError) {
                     recordSpanException(span, inputError);
-                    return {
-                        ok: false,
-                        id: execution.run.id,
-                        error: {
-                            type: "INTERNAL_ERROR",
-                            code: TaskRunErrorCodes.TASK_INPUT_ERROR,
-                            message: inputError instanceof Error
-                                ? `${inputError.name}: ${inputError.message}`
-                                : typeof inputError === "string"
-                                    ? inputError
-                                    : undefined,
-                            stackTrace: inputError instanceof Error ? inputError.stack : undefined,
-                        },
-                    };
+                    return this.#internalErrorResult(execution, TaskRunErrorCodes.TASK_INPUT_ERROR, inputError);
                 }
-                try {
-                    parsedPayload = await this.#parsePayload(parsedPayload);
-                    if (execution.attempt.number === 1) {
-                        await this.#callOnStartFunctions(parsedPayload, ctx, signal);
-                    }
-                    initOutput = await this.#callInitFunctions(parsedPayload, ctx, signal);
-                    const output = await this.#callRun(parsedPayload, ctx, initOutput, signal);
-                    await this.#callOnSuccessFunctions(parsedPayload, output, ctx, initOutput, signal);
-                    try {
-                        const stringifiedOutput = await stringifyIO(output);
-                        const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
-                        const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
-                        if (attributes) {
-                            span.setAttributes(attributes);
-                        }
-                        return {
-                            ok: true,
-                            id: execution.run.id,
-                            output: finalOutput.data,
-                            outputType: finalOutput.dataType,
-                        };
-                    }
-                    catch (outputError) {
-                        recordSpanException(span, outputError);
-                        return {
-                            ok: false,
-                            id: execution.run.id,
-                            error: {
-                                type: "INTERNAL_ERROR",
-                                code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
-                                message: outputError instanceof Error
-                                    ? outputError.message
-                                    : typeof outputError === "string"
-                                        ? outputError
-                                        : undefined,
-                            },
-                        };
-                    }
+                const [parsePayloadError, parsedPayloadResult] = await tryCatch(this.#parsePayload(payloadResult));
+                if (parsePayloadError) {
+                    recordSpanException(span, parsePayloadError);
+                    return this.#internalErrorResult(execution, TaskRunErrorCodes.TASK_INPUT_ERROR, parsePayloadError, true);
                 }
-                catch (runError) {
-                    try {
-                        const handleErrorResult = await this.#handleError(execution, runError, parsedPayload, ctx, initOutput, signal);
+                parsedPayload = parsedPayloadResult;
+                lifecycleHooks.registerOnWaitHookListener(async (wait) => {
+                    await this.#callOnWaitFunctions(wait, parsedPayload, ctx, initOutput, signal);
+                });
+                lifecycleHooks.registerOnResumeHookListener(async (wait) => {
+                    await this.#callOnResumeFunctions(wait, parsedPayload, ctx, initOutput, signal);
+                });
+                const { promise: runPromise, resolve: runResolve, reject: runReject, } = promiseWithResolvers();
+                // Make sure the run promise does not cause unhandled promise rejections
+                runPromise.catch(() => { });
+                lifecycleHooks.registerOnCancelHookListener(async () => {
+                    await this.#callOnCancelFunctions(runPromise, parsedPayload, ctx, initOutput, signal, attemptContext);
+                });
+                const executeTask = async (payload) => {
+                    const [runError, output] = await tryCatch((async () => {
+                        initOutput = await this.#callInitFunctions(payload, ctx, signal);
+                        if (execution.attempt.number === 1) {
+                            await this.#callOnStartFunctions(payload, ctx, initOutput, signal);
+                        }
+                        try {
+                            return await this.#callRun(payload, ctx, initOutput, signal);
+                        }
+                        catch (error) {
+                            if (isCompleteTaskWithOutput(error)) {
+                                return error.output;
+                            }
+                            throw error;
+                        }
+                    })());
+                    if (runError) {
+                        runReject(runError);
+                        const [handleErrorError, handleErrorResult] = await tryCatch(this.#handleError(execution, runError, payload, ctx, initOutput, signal));
+                        if (handleErrorError) {
+                            recordSpanException(span, handleErrorError);
+                            return this.#internalErrorResult(execution, TaskRunErrorCodes.HANDLE_ERROR_ERROR, handleErrorError);
+                        }
                         recordSpanException(span, handleErrorResult.error ?? runError);
                         if (handleErrorResult.status !== "retry") {
-                            await this.#callOnFailureFunctions(parsedPayload, handleErrorResult.error ?? runError, ctx, initOutput, signal);
+                            await this.#callOnFailureFunctions(payload, handleErrorResult.error ?? runError, ctx, initOutput, signal);
+                            await this.#callOnCompleteFunctions(payload, { ok: false, error: handleErrorResult.error ?? runError }, ctx, initOutput, signal);
                         }
+                        await this.#cleanupAndWaitUntil(payload, ctx, initOutput, signal);
                         return {
                             id: execution.run.id,
                             ok: false,
@@ -123,159 +105,534 @@ export class TaskExecutor {
                             skippedRetrying: handleErrorResult.status === "skipped",
                         };
                     }
-                    catch (handleErrorError) {
-                        recordSpanException(span, handleErrorError);
-                        return {
-                            ok: false,
-                            id: execution.run.id,
-                            error: {
-                                type: "INTERNAL_ERROR",
-                                code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
-                                message: handleErrorError instanceof Error
-                                    ? handleErrorError.message
-                                    : typeof handleErrorError === "string"
-                                        ? handleErrorError
-                                        : undefined,
-                            },
-                        };
+                    runResolve(output);
+                    const [outputError, stringifiedOutput] = await tryCatch(stringifyIO(output));
+                    if (outputError) {
+                        recordSpanException(span, outputError);
+                        await this.#cleanupAndWaitUntil(payload, ctx, initOutput, signal);
+                        return this.#internalErrorResult(execution, TaskRunErrorCodes.TASK_OUTPUT_ERROR, outputError);
                     }
-                }
-                finally {
-                    await this.#callTaskCleanup(parsedPayload, ctx, initOutput, signal);
-                    await this.#blockForWaitUntil();
-                }
+                    const [exportError, finalOutput] = await tryCatch(conditionallyExportPacket(stringifiedOutput, `${attemptKey(ctx)}/output`, this._tracer));
+                    if (exportError) {
+                        recordSpanException(span, exportError);
+                        await this.#cleanupAndWaitUntil(payload, ctx, initOutput, signal);
+                        return this.#internalErrorResult(execution, TaskRunErrorCodes.TASK_OUTPUT_ERROR, exportError);
+                    }
+                    const [attrError, attributes] = await tryCatch(createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE));
+                    if (!attrError && attributes) {
+                        span.setAttributes(attributes);
+                    }
+                    await this.#callOnSuccessFunctions(payload, output, ctx, initOutput, signal);
+                    await this.#callOnCompleteFunctions(payload, { ok: true, data: output }, ctx, initOutput, signal);
+                    await this.#cleanupAndWaitUntil(payload, ctx, initOutput, signal);
+                    return {
+                        ok: true,
+                        id: execution.run.id,
+                        output: finalOutput.data,
+                        outputType: finalOutput.dataType,
+                    };
+                };
+                const globalMiddlewareHooks = lifecycleHooks.getGlobalMiddlewareHooks();
+                const taskMiddlewareHook = lifecycleHooks.getTaskMiddlewareHook(this.task.id);
+                const middlewareHooks = [
+                    ...globalMiddlewareHooks,
+                    taskMiddlewareHook ? { id: this.task.id, fn: taskMiddlewareHook } : undefined,
+                ].filter(Boolean);
+                return await this.#executeTaskWithMiddlewareHooks(parsedPayload, ctx, execution, middlewareHooks, executeTask, signal);
             });
         }, {
             kind: SpanKind.CONSUMER,
             attributes: {
                 [SemanticInternalAttributes.STYLE_ICON]: "attempt",
+                [SemanticInternalAttributes.ENTITY_TYPE]: "attempt",
+                [SemanticInternalAttributes.SPAN_ATTEMPT]: true,
+                ...(execution.attempt.number === 1
+                    ? runTimelineMetrics.convertMetricsToSpanAttributes()
+                    : {}),
+                [SemanticInternalAttributes.STYLE_VARIANT]: this._isWarmStart
+                    ? WARM_VARIANT
+                    : COLD_VARIANT,
+                ...(typeof this._executionCount === "number"
+                    ? {
+                        [SemanticInternalAttributes.ATTEMPT_EXECUTION_COUNT]: this._executionCount,
+                    }
+                    : {}),
             },
-        }, this._tracer.extractContext(traceContext), signal);
+            events: execution.attempt.number === 1
+                ? runTimelineMetrics.convertMetricsToSpanEvents()
+                : undefined,
+        }, traceContext.extractContext(), signal);
         return { result };
     }
+    async #executeTaskWithMiddlewareHooks(payload, ctx, execution, hooks, executeTask, signal) {
+        let output;
+        let executeError;
+        const runner = hooks.reduceRight((next, hook) => {
+            return async () => {
+                await this._tracer.startActiveSpan("middleware()", async (span) => {
+                    await hook.fn({ payload, ctx, signal, task: this.task.id, next });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-middleware",
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                });
+            };
+        }, async () => {
+            const [error, result] = await tryCatch(executeTask(payload));
+            if (error) {
+                executeError = error;
+            }
+            else {
+                output = result;
+            }
+        });
+        const [runnerError] = await tryCatch(runner());
+        if (runnerError) {
+            return this.#internalErrorResult(execution, TaskRunErrorCodes.TASK_MIDDLEWARE_ERROR, runnerError);
+        }
+        if (executeError) {
+            throw executeError;
+        }
+        return output;
+    }
     async #callRun(payload, ctx, init, signal) {
         const runFn = this.task.fns.run;
-        const middlewareFn = this.task.fns.middleware;
         if (!runFn) {
             throw new Error("Task does not have a run function");
         }
-        if (!middlewareFn) {
-            return runFn(payload, { ctx, init, signal });
+        // Create a promise that rejects when the signal aborts
+        const abortPromise = new Promise((_, reject) => {
+            signal.addEventListener("abort", () => {
+                if (typeof signal.reason === "string" && signal.reason.includes("cancel")) {
+                    return;
+                }
+                const maxDuration = ctx.run.maxDuration;
+                reject(new InternalError({
+                    code: TaskRunErrorCodes.MAX_DURATION_EXCEEDED,
+                    message: `Run exceeded maximum compute time (maxDuration) of ${maxDuration} seconds`,
+                }));
+            });
+        });
+        return runTimelineMetrics.measureMetric("trigger.dev/execution", "run", async () => {
+            return await this._tracer.startActiveSpan("run()", async (span) => {
+                // Race between the run function and the abort promise
+                return await Promise.race([runFn(payload, { ctx, init, signal }), abortPromise]);
+            }, {
+                attributes: { [SemanticInternalAttributes.STYLE_ICON]: "task-fn-run" },
+            });
+        });
+    }
+    async #callOnWaitFunctions(wait, payload, ctx, initOutput, signal) {
+        const globalWaitHooks = lifecycleHooks.getGlobalWaitHooks();
+        const taskWaitHook = lifecycleHooks.getTaskWaitHook(this.task.id);
+        if (globalWaitHooks.length === 0 && !taskWaitHook) {
+            return;
+        }
+        const result = await runTimelineMetrics.measureMetric("trigger.dev/execution", "onWait", async () => {
+            for (const hook of globalWaitHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onWait()", async (span) => {
+                    await hook.fn({ payload, ctx, signal, task: this.task.id, wait, init: initOutput });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onWait",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskWaitHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onWait()", async (span) => {
+                    await taskWaitHook({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        wait,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onWait",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+        });
+    }
+    async #callOnCancelFunctions(runPromise, payload, ctx, initOutput, signal, attemptContext) {
+        const globalCancelHooks = lifecycleHooks.getGlobalCancelHooks();
+        const taskCancelHook = lifecycleHooks.getTaskCancelHook(this.task.id);
+        if (globalCancelHooks.length === 0 && !taskCancelHook) {
+            return;
         }
-        return middlewareFn(payload, {
-            ctx,
-            signal,
-            next: async () => runFn(payload, { ctx, init, signal }),
+        const result = await runTimelineMetrics.measureMetric("trigger.dev/execution", "onCancel", async () => {
+            for (const hook of globalCancelHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onCancel()", async (span) => {
+                    await hook.fn({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                        runPromise,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onCancel",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }, attemptContext));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskCancelHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onCancel()", async (span) => {
+                    await taskCancelHook({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                        runPromise,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onCancel",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }, attemptContext));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
         });
     }
-    async #callInitFunctions(payload, ctx, signal) {
-        await this.#callConfigInit(payload, ctx, signal);
-        const initFn = this.task.fns.init;
-        if (!initFn) {
-            return {};
+    async #callOnResumeFunctions(wait, payload, ctx, initOutput, signal) {
+        const globalResumeHooks = lifecycleHooks.getGlobalResumeHooks();
+        const taskResumeHook = lifecycleHooks.getTaskResumeHook(this.task.id);
+        if (globalResumeHooks.length === 0 && !taskResumeHook) {
+            return;
         }
-        return this._tracer.startActiveSpan("init", async (span) => {
-            return await initFn(payload, { ctx, signal });
-        }, {
-            attributes: {
-                [SemanticInternalAttributes.STYLE_ICON]: "function",
-            },
+        const result = await runTimelineMetrics.measureMetric("trigger.dev/execution", "onResume", async () => {
+            for (const hook of globalResumeHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onResume()", async (span) => {
+                    await hook.fn({ payload, ctx, signal, task: this.task.id, wait, init: initOutput });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onResume",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskResumeHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onResume()", async (span) => {
+                    await taskResumeHook({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        wait,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onResume",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
         });
     }
-    async #callConfigInit(payload, ctx, signal) {
-        const initFn = this._importedConfig?.init;
-        if (!initFn) {
+    async #callInitFunctions(payload, ctx, signal) {
+        const globalInitHooks = lifecycleHooks.getGlobalInitHooks();
+        const taskInitHook = lifecycleHooks.getTaskInitHook(this.task.id);
+        if (globalInitHooks.length === 0 && !taskInitHook) {
             return {};
         }
-        return this._tracer.startActiveSpan("config.init", async (span) => {
-            return await initFn(payload, { ctx, signal });
-        }, {
-            attributes: {
-                [SemanticInternalAttributes.STYLE_ICON]: "function",
-            },
+        const result = await runTimelineMetrics.measureMetric("trigger.dev/execution", "init", async () => {
+            // Store global hook results in an array
+            const globalResults = [];
+            for (const hook of globalInitHooks) {
+                const [hookError, result] = await tryCatch(this._tracer.startActiveSpan("init()", async (span) => {
+                    const result = await hook.fn({ payload, ctx, signal, task: this.task.id });
+                    if (result && typeof result === "object" && !Array.isArray(result)) {
+                        span.setAttributes(flattenAttributes(result, undefined, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT));
+                        return result;
+                    }
+                    return {};
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-init",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+                if (result && typeof result === "object" && !Array.isArray(result)) {
+                    globalResults.push(result);
+                }
+            }
+            // Merge all global results into a single object
+            const mergedGlobalResults = Object.assign({}, ...globalResults);
+            if (taskInitHook) {
+                const [hookError, taskResult] = await tryCatch(this._tracer.startActiveSpan("init()", async (span) => {
+                    const result = await taskInitHook({ payload, ctx, signal, task: this.task.id });
+                    if (result && typeof result === "object" && !Array.isArray(result)) {
+                        span.setAttributes(flattenAttributes(result, undefined, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT));
+                        return result;
+                    }
+                    return {};
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-init",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+                // Only merge if taskResult is an object
+                if (taskResult && typeof taskResult === "object" && !Array.isArray(taskResult)) {
+                    return { ...mergedGlobalResults, ...taskResult };
+                }
+                // If taskResult isn't an object, return global results
+                return mergedGlobalResults;
+            }
+            return mergedGlobalResults;
         });
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+            return result;
+        }
+        return;
     }
     async #callOnSuccessFunctions(payload, output, ctx, initOutput, signal) {
-        await this.#callOnSuccessFunction(this.task.fns.onSuccess, "task.onSuccess", payload, output, ctx, initOutput, signal);
-        await this.#callOnSuccessFunction(this._importedConfig?.onSuccess, "config.onSuccess", payload, output, ctx, initOutput, signal);
-    }
-    async #callOnSuccessFunction(onSuccessFn, name, payload, output, ctx, initOutput, signal) {
-        if (!onSuccessFn) {
+        const globalSuccessHooks = lifecycleHooks.getGlobalSuccessHooks();
+        const taskSuccessHook = lifecycleHooks.getTaskSuccessHook(this.task.id);
+        if (globalSuccessHooks.length === 0 && !taskSuccessHook) {
             return;
         }
-        try {
-            await this._tracer.startActiveSpan(name, async (span) => {
-                return await onSuccessFn(payload, output, { ctx, init: initOutput, signal });
-            }, {
-                attributes: {
-                    [SemanticInternalAttributes.STYLE_ICON]: "function",
-                },
-            });
-        }
-        catch {
-            // Ignore errors from onSuccess functions
-        }
+        return await runTimelineMetrics.measureMetric("trigger.dev/execution", "success", async () => {
+            for (const hook of globalSuccessHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onSuccess()", async (span) => {
+                    await hook.fn({
+                        payload,
+                        output,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onSuccess",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskSuccessHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onSuccess()", async (span) => {
+                    await taskSuccessHook({
+                        payload,
+                        output,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onSuccess",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+        });
     }
     async #callOnFailureFunctions(payload, error, ctx, initOutput, signal) {
-        await this.#callOnFailureFunction(this.task.fns.onFailure, "task.onFailure", payload, error, ctx, initOutput, signal);
-        await this.#callOnFailureFunction(this._importedConfig?.onFailure, "config.onFailure", payload, error, ctx, initOutput, signal);
-    }
-    async #callOnFailureFunction(onFailureFn, name, payload, error, ctx, initOutput, signal) {
-        if (!onFailureFn) {
+        const globalFailureHooks = lifecycleHooks.getGlobalFailureHooks();
+        const taskFailureHook = lifecycleHooks.getTaskFailureHook(this.task.id);
+        if (globalFailureHooks.length === 0 && !taskFailureHook) {
             return;
         }
-        try {
-            return await this._tracer.startActiveSpan(name, async (span) => {
-                return await onFailureFn(payload, error, { ctx, init: initOutput, signal });
-            }, {
-                attributes: {
-                    [SemanticInternalAttributes.STYLE_ICON]: "function",
-                },
-            });
-        }
-        catch (e) {
-            // Ignore errors from onFailure functions
-        }
+        return await runTimelineMetrics.measureMetric("trigger.dev/execution", "failure", async () => {
+            for (const hook of globalFailureHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onFailure()", async (span) => {
+                    await hook.fn({
+                        payload,
+                        error,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onFailure",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskFailureHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onFailure()", async (span) => {
+                    await taskFailureHook({
+                        payload,
+                        error,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onFailure",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+        });
     }
     async #parsePayload(payload) {
         if (!this.task.fns.parsePayload) {
             return payload;
         }
-        try {
-            return await this.task.fns.parsePayload(payload);
-        }
-        catch (e) {
-            throw new TaskPayloadParsedError(e);
+        const [parseError, result] = await tryCatch(this.task.fns.parsePayload(payload));
+        if (parseError) {
+            throw new TaskPayloadParsedError(parseError);
         }
+        return result;
     }
-    async #callOnStartFunctions(payload, ctx, signal) {
-        await this.#callOnStartFunction(this._importedConfig?.onStart, "config.onStart", payload, ctx, {}, signal);
-        await this.#callOnStartFunction(this.task.fns.onStart, "task.onStart", payload, ctx, {}, signal);
-    }
-    async #callOnStartFunction(onStartFn, name, payload, ctx, initOutput, signal) {
-        if (!onStartFn) {
+    async #callOnStartFunctions(payload, ctx, initOutput, signal) {
+        const globalStartHooks = lifecycleHooks.getGlobalStartHooks();
+        const taskStartHook = lifecycleHooks.getTaskStartHook(this.task.id);
+        if (globalStartHooks.length === 0 && !taskStartHook) {
             return;
         }
-        try {
-            await this._tracer.startActiveSpan(name, async (span) => {
-                return await onStartFn(payload, { ctx, signal });
-            }, {
-                attributes: {
-                    [SemanticInternalAttributes.STYLE_ICON]: "function",
-                },
-            });
-        }
-        catch {
-            // Ignore errors from onStart functions
-        }
+        return await runTimelineMetrics.measureMetric("trigger.dev/execution", "start", async () => {
+            for (const hook of globalStartHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onStart()", async (span) => {
+                    await hook.fn({ payload, ctx, signal, task: this.task.id, init: initOutput });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStart",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskStartHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onStart()", async (span) => {
+                    await taskStartHook({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStart",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+        });
+    }
+    async #cleanupAndWaitUntil(payload, ctx, initOutput, signal) {
+        await this.#callCleanupFunctions(payload, ctx, initOutput, signal);
+        await this.#blockForWaitUntil();
     }
-    async #callTaskCleanup(payload, ctx, init, signal) {
-        const cleanupFn = this.task.fns.cleanup;
-        if (!cleanupFn) {
+    async #callCleanupFunctions(payload, ctx, initOutput, signal) {
+        const globalCleanupHooks = lifecycleHooks.getGlobalCleanupHooks();
+        const taskCleanupHook = lifecycleHooks.getTaskCleanupHook(this.task.id);
+        if (globalCleanupHooks.length === 0 && !taskCleanupHook) {
             return;
         }
-        return this._tracer.startActiveSpan("cleanup", async (span) => {
-            return await cleanupFn(payload, { ctx, init, signal });
+        return await runTimelineMetrics.measureMetric("trigger.dev/execution", "cleanup", async () => {
+            for (const hook of globalCleanupHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("cleanup()", async (span) => {
+                    await hook.fn({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-cleanup",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
+            if (taskCleanupHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("cleanup()", async (span) => {
+                    await taskCleanupHook({
+                        payload,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-cleanup",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
+            }
         });
     }
     async #blockForWaitUntil() {
@@ -286,100 +643,226 @@ export class TaskExecutor {
             return await waitUntil.blockUntilSettled(60_000);
         }, {
             attributes: {
-                [SemanticInternalAttributes.STYLE_ICON]: "clock",
+                [SemanticInternalAttributes.STYLE_ICON]: "tabler-clock",
+                [SemanticInternalAttributes.COLLAPSED]: true,
             },
         });
     }
     async #handleError(execution, error, payload, ctx, init, signal) {
-        const retriesConfig = this._importedConfig?.retries;
+        const retriesConfig = this._retries;
         const retry = this.task.retry ?? retriesConfig?.default;
-        if (!retry) {
-            return { status: "noop" };
+        // Early exit conditions that prevent retrying
+        if (isInternalError(error) && error.skipRetrying) {
+            return { status: "skipped", error };
         }
         if (error instanceof Error &&
             (error.name === "AbortTaskRunError" || error.name === "TaskPayloadParsedError")) {
             return { status: "skipped" };
         }
-        if (execution.run.maxAttempts) {
-            retry.maxAttempts = Math.max(execution.run.maxAttempts, 1);
-        }
-        let delay = calculateNextRetryDelay(retry, execution.attempt.number);
-        if (delay &&
-            error instanceof Error &&
+        // Check for unretryable API errors (client errors except 408 and 429)
+        if (error instanceof Error &&
             error.name === "TriggerApiError" &&
-            error.status === 429) {
-            const rateLimitError = error;
-            delay = rateLimitError.millisecondsUntilReset;
+            "status" in error &&
+            typeof error.status === "number") {
+            const status = error.status;
+            if (status && status >= 400 && status < 500 && status !== 408 && status !== 429) {
+                return { status: "skipped", error };
+            }
         }
+        // Calculate default retry delay if retry config exists
+        let defaultDelay;
+        if (retry) {
+            if (execution.run.maxAttempts) {
+                retry.maxAttempts = Math.max(execution.run.maxAttempts, 1);
+            }
+            defaultDelay = calculateNextRetryDelay(retry, execution.attempt.number);
+            // Handle rate limit errors
+            if (defaultDelay &&
+                error instanceof Error &&
+                error.name === "TriggerApiError" &&
+                error.status === 429) {
+                const rateLimitError = error;
+                const rateLimitDelay = rateLimitError.millisecondsUntilReset;
+                if (rateLimitDelay) {
+                    defaultDelay = rateLimitDelay;
+                }
+            }
+        }
+        const defaultRetryResult = typeof defaultDelay === "undefined"
+            ? { status: "noop" }
+            : {
+                status: "retry",
+                retry: { timestamp: Date.now() + defaultDelay, delay: defaultDelay },
+            };
+        // Check if retries are enabled in dev environment
         if (execution.environment.type === "DEVELOPMENT" &&
             typeof retriesConfig?.enabledInDev === "boolean" &&
             !retriesConfig.enabledInDev) {
             return { status: "skipped" };
         }
-        return this._tracer.startActiveSpan("handleError()", async (span) => {
-            const handleErrorResult = this.task.fns.handleError
-                ? await this.task.fns.handleError(payload, error, {
+        const taskCatchErrorHook = lifecycleHooks.getTaskCatchErrorHook(this.task.id);
+        const globalCatchErrorHooks = lifecycleHooks.getGlobalCatchErrorHooks();
+        if (globalCatchErrorHooks.length === 0 && !taskCatchErrorHook) {
+            return defaultRetryResult;
+        }
+        return this._tracer.startActiveSpan("catchError", async (span) => {
+            // Try task-specific catch error hook first
+            if (taskCatchErrorHook) {
+                const result = await taskCatchErrorHook({
+                    payload,
+                    error,
                     ctx,
                     init,
                     retry,
-                    retryDelayInMs: delay,
-                    retryAt: delay ? new Date(Date.now() + delay) : undefined,
+                    retryDelayInMs: defaultDelay,
+                    retryAt: defaultDelay ? new Date(Date.now() + defaultDelay) : undefined,
                     signal,
-                })
-                : this._importedConfig
-                    ? await this._handleErrorFn?.(payload, error, {
-                        ctx,
-                        init,
-                        retry,
-                        retryDelayInMs: delay,
-                        retryAt: delay ? new Date(Date.now() + delay) : undefined,
-                        signal,
-                    })
-                    : undefined;
-            // If handleErrorResult
-            if (!handleErrorResult) {
-                return typeof delay === "undefined"
-                    ? { status: "noop" }
-                    : { status: "retry", retry: { timestamp: Date.now() + delay, delay } };
+                    task: this.task.id,
+                });
+                if (result) {
+                    return this.#processHandleErrorResult(result, execution.attempt.number, defaultDelay);
+                }
             }
-            if (handleErrorResult.skipRetrying) {
-                return { status: "skipped", error: handleErrorResult.error };
+            // Try global catch error hooks in order
+            for (const hook of globalCatchErrorHooks) {
+                const result = await hook.fn({
+                    payload,
+                    error,
+                    ctx,
+                    init,
+                    retry,
+                    retryDelayInMs: defaultDelay,
+                    retryAt: defaultDelay ? new Date(Date.now() + defaultDelay) : undefined,
+                    signal,
+                    task: this.task.id,
+                });
+                if (result) {
+                    return this.#processHandleErrorResult(result, execution.attempt.number, defaultDelay);
+                }
             }
-            if (typeof handleErrorResult.retryAt !== "undefined") {
-                return {
+            // If no hooks handled the error, use default retry behavior
+            return defaultRetryResult;
+        }, {
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "task-hook-catchError",
+                [SemanticInternalAttributes.COLLAPSED]: true,
+            },
+        });
+    }
+    // Helper method to process handle error results
+    #processHandleErrorResult(result, attemptNumber, defaultDelay) {
+        if (result.skipRetrying) {
+            return { status: "skipped", error: result.error };
+        }
+        if (typeof result.retryAt !== "undefined") {
+            return {
+                status: "retry",
+                retry: {
+                    timestamp: result.retryAt.getTime(),
+                    delay: result.retryAt.getTime() - Date.now(),
+                },
+                error: result.error,
+            };
+        }
+        if (typeof result.retryDelayInMs === "number") {
+            return {
+                status: "retry",
+                retry: {
+                    timestamp: Date.now() + result.retryDelayInMs,
+                    delay: result.retryDelayInMs,
+                },
+                error: result.error,
+            };
+        }
+        if (result.retry && typeof result.retry === "object") {
+            const delay = calculateNextRetryDelay(result.retry, attemptNumber);
+            return typeof delay === "undefined"
+                ? { status: "noop", error: result.error }
+                : {
                     status: "retry",
-                    retry: {
-                        timestamp: handleErrorResult.retryAt.getTime(),
-                        delay: handleErrorResult.retryAt.getTime() - Date.now(),
-                    },
-                    error: handleErrorResult.error,
+                    retry: { timestamp: Date.now() + delay, delay },
+                    error: result.error,
                 };
-            }
-            if (typeof handleErrorResult.retryDelayInMs === "number") {
-                return {
-                    status: "retry",
-                    retry: {
-                        timestamp: Date.now() + handleErrorResult.retryDelayInMs,
-                        delay: handleErrorResult.retryDelayInMs,
+        }
+        return { status: "noop", error: result.error };
+    }
+    async #callOnCompleteFunctions(payload, result, ctx, initOutput, signal) {
+        const globalCompleteHooks = lifecycleHooks.getGlobalCompleteHooks();
+        const taskCompleteHook = lifecycleHooks.getTaskCompleteHook(this.task.id);
+        if (globalCompleteHooks.length === 0 && !taskCompleteHook) {
+            return;
+        }
+        return await runTimelineMetrics.measureMetric("trigger.dev/execution", "complete", async () => {
+            for (const hook of globalCompleteHooks) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onComplete()", async (span) => {
+                    await hook.fn({
+                        payload,
+                        result,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onComplete",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes(hook.name),
                     },
-                    error: handleErrorResult.error,
-                };
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
             }
-            if (handleErrorResult.retry && typeof handleErrorResult.retry === "object") {
-                const delay = calculateNextRetryDelay(handleErrorResult.retry, execution.attempt.number);
-                return typeof delay === "undefined"
-                    ? { status: "noop", error: handleErrorResult.error }
-                    : {
-                        status: "retry",
-                        retry: { timestamp: Date.now() + delay, delay },
-                        error: handleErrorResult.error,
-                    };
+            if (taskCompleteHook) {
+                const [hookError] = await tryCatch(this._tracer.startActiveSpan("onComplete()", async (span) => {
+                    await taskCompleteHook({
+                        payload,
+                        result,
+                        ctx,
+                        signal,
+                        task: this.task.id,
+                        init: initOutput,
+                    });
+                }, {
+                    attributes: {
+                        [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onComplete",
+                        [SemanticInternalAttributes.COLLAPSED]: true,
+                        ...this.#lifecycleHookAccessoryAttributes("task"),
+                    },
+                }));
+                if (hookError) {
+                    throw hookError;
+                }
             }
-            return { status: "noop", error: handleErrorResult.error };
-        }, {
-            attributes: {
-                [SemanticInternalAttributes.STYLE_ICON]: "exclamation-circle",
+        });
+    }
+    #internalErrorResult(execution, code, error, skippedRetrying) {
+        return {
+            ok: false,
+            id: execution.run.id,
+            error: {
+                type: "INTERNAL_ERROR",
+                code,
+                message: error instanceof Error
+                    ? `${error.name}: ${error.message}`
+                    : typeof error === "string"
+                        ? error
+                        : undefined,
+                stackTrace: error instanceof Error ? error.stack : undefined,
             },
+            skippedRetrying,
+        };
+    }
+    #lifecycleHookAccessoryAttributes(name) {
+        return accessoryAttributes({
+            items: [
+                {
+                    text: name ?? "global",
+                    variant: "normal",
+                },
+            ],
+            style: "codepath",
         });
     }
 }