@trigger.dev/core 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/v3/workers/index.d.mts

@@ -4,8 +4,8 @@ export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.mj
 import { p as TaskRunExecution, T as TaskRunExecutionResult } from '../../manager-M9GLDnhJ.mjs';
 export { R as RuntimeManager } from '../../manager-M9GLDnhJ.mjs';
 import { B as BackgroundWorkerProperties, T as TaskFileMetadata, a as TaskMetadataWithFilePath } from '../../messages-AriaDDm0.mjs';
-import { d as TriggerTracer, g as Config, y as ProjectConfig, w as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-A-D3UC6S.mjs';
-export { O as OtelTaskLogger, z as logLevels } from '../../catalog-A-D3UC6S.mjs';
+import { d as TriggerTracer, g as Config, z as ProjectConfig, x as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-PA64uhhi.mjs';
+export { O as OtelTaskLogger, A as logLevels } from '../../catalog-PA64uhhi.mjs';
 import { PreciseDate } from '@google-cloud/precise-date';
 import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
 import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';

package/dist/v3/workers/index.d.ts

@@ -4,8 +4,8 @@ export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.js
 import { p as TaskRunExecution, T as TaskRunExecutionResult } from '../../manager-M9GLDnhJ.js';
 export { R as RuntimeManager } from '../../manager-M9GLDnhJ.js';
 import { B as BackgroundWorkerProperties, T as TaskFileMetadata, a as TaskMetadataWithFilePath } from '../../messages-AriaDDm0.js';
-import { d as TriggerTracer, g as Config, y as ProjectConfig, w as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-TAZd4-TP.js';
-export { O as OtelTaskLogger, z as logLevels } from '../../catalog-TAZd4-TP.js';
+import { d as TriggerTracer, g as Config, z as ProjectConfig, x as HandleErrorFunction, c as TaskMetadataWithFunctions, C as Clock, a as ClockTime, b as TaskCatalog } from '../../catalog-KJXg8k3W.js';
+export { O as OtelTaskLogger, A as logLevels } from '../../catalog-KJXg8k3W.js';
 import { PreciseDate } from '@google-cloud/precise-date';
 import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
 import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';

package/dist/v3/workers/index.js

@@ -1975,11 +1975,18 @@ function accessoryAttributes(accessory) {
 __name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/workers/taskExecutor.ts
-var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _callRun, callRun_fn, _callInitFunctions, callInitFunctions_fn, _callConfigInit, callConfigInit_fn, _callOnSuccessFunctions, callOnSuccessFunctions_fn, _callOnSuccessFunction, callOnSuccessFunction_fn, _callOnFailureFunctions, callOnFailureFunctions_fn, _callOnFailureFunction, callOnFailureFunction_fn, _callOnStartFunctions, callOnStartFunctions_fn, _callOnStartFunction, callOnStartFunction_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
 var _TaskExecutor = class _TaskExecutor {
   constructor(task, options) {
     __privateAdd(this, _callRun);
-    __privateAdd(this, _callTaskInit);
+    __privateAdd(this, _callInitFunctions);
+    __privateAdd(this, _callConfigInit);
+    __privateAdd(this, _callOnSuccessFunctions);
+    __privateAdd(this, _callOnSuccessFunction);
+    __privateAdd(this, _callOnFailureFunctions);
+    __privateAdd(this, _callOnFailureFunction);
+    __privateAdd(this, _callOnStartFunctions);
+    __privateAdd(this, _callOnStartFunction);
     __privateAdd(this, _callTaskCleanup);
     __privateAdd(this, _handleError);
     this.task = task;
@@ -2013,8 +2020,12 @@ var _TaskExecutor = class _TaskExecutor {
         try {
           const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
           parsedPayload = await parsePacket(payloadPacket);
-          initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          if (execution.attempt.number === 1) {
+            await __privateMethod(this, _callOnStartFunctions, callOnStartFunctions_fn).call(this, parsedPayload, ctx);
+          }
+          initOutput = await __privateMethod(this, _callInitFunctions, callInitFunctions_fn).call(this, parsedPayload, ctx);
           const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+          await __privateMethod(this, _callOnSuccessFunctions, callOnSuccessFunctions_fn).call(this, parsedPayload, output, ctx, initOutput);
           try {
             const stringifiedOutput = await stringifyIO(output);
             const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
@@ -2044,6 +2055,9 @@ var _TaskExecutor = class _TaskExecutor {
           try {
             const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
             recordSpanException(span, handleErrorResult.error ?? runError);
+            if (handleErrorResult.status !== "retry") {
+              await __privateMethod(this, _callOnFailureFunctions, callOnFailureFunctions_fn).call(this, parsedPayload, handleErrorResult.error ?? runError, ctx, initOutput);
+            }
             return {
               id: execution.run.id,
               ok: false,
@@ -2107,8 +2121,9 @@ callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
     })
   });
 }, "#callRun");
-_callTaskInit = new WeakSet();
-callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+_callInitFunctions = new WeakSet();
+callInitFunctions_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  await __privateMethod(this, _callConfigInit, callConfigInit_fn).call(this, payload1, ctx1);
   const initFn = this.task.fns.init;
   if (!initFn) {
     return {};
@@ -2117,23 +2132,114 @@ callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
     return await initFn(payload1, {
       ctx: ctx1
     });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
+  });
+}, "#callInitFunctions");
+_callConfigInit = new WeakSet();
+callConfigInit_fn = /* @__PURE__ */ __name(async function(payload2, ctx2) {
+  const initFn = this._importedConfig?.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("config.init", async (span) => {
+    return await initFn(payload2, {
+      ctx: ctx2
+    });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
   });
-}, "#callTaskInit");
+}, "#callConfigInit");
+_callOnSuccessFunctions = new WeakSet();
+callOnSuccessFunctions_fn = /* @__PURE__ */ __name(async function(payload3, output, ctx3, initOutput) {
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this.task.fns.onSuccess, "task.onSuccess", payload3, output, ctx3, initOutput);
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this._importedConfig?.onSuccess, "config.onSuccess", payload3, output, ctx3, initOutput);
+}, "#callOnSuccessFunctions");
+_callOnSuccessFunction = new WeakSet();
+callOnSuccessFunction_fn = /* @__PURE__ */ __name(async function(onSuccessFn, name, payload4, output1, ctx4, initOutput1) {
+  if (!onSuccessFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name, async (span) => {
+      return await onSuccessFn(payload4, output1, {
+        ctx: ctx4,
+        init: initOutput1
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnSuccessFunction");
+_callOnFailureFunctions = new WeakSet();
+callOnFailureFunctions_fn = /* @__PURE__ */ __name(async function(payload5, error, ctx5, initOutput2) {
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this.task.fns.onFailure, "task.onFailure", payload5, error, ctx5, initOutput2);
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this._importedConfig?.onFailure, "config.onFailure", payload5, error, ctx5, initOutput2);
+}, "#callOnFailureFunctions");
+_callOnFailureFunction = new WeakSet();
+callOnFailureFunction_fn = /* @__PURE__ */ __name(async function(onFailureFn, name1, payload6, error1, ctx6, initOutput3) {
+  if (!onFailureFn) {
+    return;
+  }
+  try {
+    return await this._tracer.startActiveSpan(name1, async (span) => {
+      return await onFailureFn(payload6, error1, {
+        ctx: ctx6,
+        init: initOutput3
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch (e) {
+  }
+}, "#callOnFailureFunction");
+_callOnStartFunctions = new WeakSet();
+callOnStartFunctions_fn = /* @__PURE__ */ __name(async function(payload7, ctx7) {
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this._importedConfig?.onStart, "config.onStart", payload7, ctx7, {});
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this.task.fns.onStart, "task.onStart", payload7, ctx7, {});
+}, "#callOnStartFunctions");
+_callOnStartFunction = new WeakSet();
+callOnStartFunction_fn = /* @__PURE__ */ __name(async function(onStartFn, name2, payload8, ctx8, initOutput4) {
+  if (!onStartFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name2, async (span) => {
+      return await onStartFn(payload8, {
+        ctx: ctx8
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnStartFunction");
 _callTaskCleanup = new WeakSet();
-callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload9, ctx9, init1) {
   const cleanupFn = this.task.fns.cleanup;
   if (!cleanupFn) {
     return;
   }
   return this._tracer.startActiveSpan("cleanup", async (span) => {
-    return await cleanupFn(payload2, {
-      ctx: ctx2,
+    return await cleanupFn(payload9, {
+      ctx: ctx9,
       init: init1
     });
   });
 }, "#callTaskCleanup");
 _handleError = new WeakSet();
-handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error2, payload10, ctx10) {
   const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
   const retry = this.task.retry ?? retriesConfig?.default;
   if (!retry) {
@@ -2148,13 +2254,13 @@ handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload
     };
   }
   return this._tracer.startActiveSpan("handleError()", async (span) => {
-    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
-      ctx: ctx3,
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
-      ctx: ctx3,
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0