trigger.dev 0.0.0-v3-prerelease-20240813130521 → 0.0.0-v3-prerelease-20240912191953

package/dist/workers/prod/worker-facade.js

@@ -1,223 +0,0 @@
-// src/workers/prod/worker-facade.ts
-import {
-  ProdChildToWorkerMessages,
-  ProdWorkerToChildMessages,
-  clock,
-  taskCatalog
-} from "@trigger.dev/core/v3";
-import {
-  ConsoleInterceptor,
-  DevUsageManager,
-  DurableClock,
-  OtelTaskLogger,
-  ProdUsageManager,
-  TaskExecutor,
-  getEnvVar,
-  logLevels,
-  usage
-} from "@trigger.dev/core/v3/workers";
-import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
-import { ZodSchemaParsedError } from "@trigger.dev/core/v3/zodMessageHandler";
-import "source-map-support/register.js";
-import {
-  TaskRunErrorCodes,
-  TriggerTracer,
-  logger,
-  runtime
-} from "@trigger.dev/core/v3";
-import { ProdRuntimeManager } from "@trigger.dev/core/v3/prod";
-__WORKER_SETUP__;
-__IMPORTED_PROJECT_CONFIG__;
-var heartbeatIntervalMs = getEnvVar("USAGE_HEARTBEAT_INTERVAL_MS");
-var usageEventUrl = getEnvVar("USAGE_EVENT_URL");
-var triggerJWT = getEnvVar("TRIGGER_JWT");
-var prodUsageManager = new ProdUsageManager(new DevUsageManager(), {
-  heartbeatIntervalMs: heartbeatIntervalMs ? parseInt(heartbeatIntervalMs, 10) : void 0,
-  url: usageEventUrl,
-  jwt: triggerJWT
-});
-usage.setGlobalUsageManager(prodUsageManager);
-var durableClock = new DurableClock();
-clock.setGlobalClock(durableClock);
-var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
-var consoleInterceptor = new ConsoleInterceptor(otelLogger, true);
-var triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
-var configLogLevel = triggerLogLevel ? triggerLogLevel : importedConfig ? importedConfig.logLevel : __PROJECT_CONFIG__.logLevel;
-var otelTaskLogger = new OtelTaskLogger({
-  logger: otelLogger,
-  tracer,
-  level: logLevels.includes(configLogLevel) ? configLogLevel : "info"
-});
-logger.setGlobalTaskLogger(otelTaskLogger);
-var TaskFileImports = {};
-var TaskFiles = {};
-__TASKS__;
-(() => {
-  for (const [importName, taskFile] of Object.entries(TaskFiles)) {
-    const fileImports = TaskFileImports[importName];
-    for (const [exportName, task] of Object.entries(fileImports ?? {})) {
-      if (typeof task === "object" && task !== null && "id" in task && typeof task.id === "string") {
-        if (taskCatalog.taskExists(task.id)) {
-          taskCatalog.registerTaskFileMetadata(task.id, {
-            exportName,
-            filePath: taskFile.filePath
-          });
-        }
-      }
-    }
-  }
-})();
-var _execution;
-var _isRunning = false;
-var zodIpc = new ZodIpcConnection({
-  listenSchema: ProdWorkerToChildMessages,
-  emitSchema: ProdChildToWorkerMessages,
-  process,
-  handlers: {
-    EXECUTE_TASK_RUN: async ({ execution, traceContext, metadata }, sender) => {
-      if (_isRunning) {
-        console.error("Worker is already running a task");
-        await sender.send("TASK_RUN_COMPLETED", {
-          execution,
-          result: {
-            ok: false,
-            id: execution.run.id,
-            error: {
-              type: "INTERNAL_ERROR",
-              code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
-            }
-          }
-        });
-        return;
-      }
-      process.title = `trigger-prod-worker: ${execution.task.id} ${execution.run.id}`;
-      const task = taskCatalog.getTask(execution.task.id);
-      if (!task) {
-        console.error(`Could not find task ${execution.task.id}`);
-        await sender.send("TASK_RUN_COMPLETED", {
-          execution,
-          result: {
-            ok: false,
-            id: execution.run.id,
-            error: {
-              type: "INTERNAL_ERROR",
-              code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
-            }
-          }
-        });
-        return;
-      }
-      const executor = new TaskExecutor(task, {
-        tracer,
-        tracingSDK,
-        consoleInterceptor,
-        projectConfig: __PROJECT_CONFIG__,
-        importedConfig,
-        handleErrorFn: handleError
-      });
-      try {
-        _execution = execution;
-        _isRunning = true;
-        const measurement = usage.start();
-        const { result } = await executor.execute(execution, metadata, traceContext, measurement);
-        const usageSample = usage.stop(measurement);
-        return await sender.send("TASK_RUN_COMPLETED", {
-          execution,
-          result: {
-            ...result,
-            usage: {
-              durationMs: usageSample.cpuTime
-            }
-          }
-        });
-      } finally {
-        _execution = void 0;
-        _isRunning = false;
-      }
-    },
-    TASK_RUN_COMPLETED_NOTIFICATION: async ({ completion }) => {
-      prodRuntimeManager.resumeTask(completion);
-    },
-    WAIT_COMPLETED_NOTIFICATION: async () => {
-      prodRuntimeManager.resumeAfterDuration();
-    },
-    CLEANUP: async ({ flush, kill }, sender) => {
-      if (kill) {
-        await flushAll();
-        await sender.send("READY_TO_DISPOSE", void 0);
-      } else {
-        if (flush) {
-          await flushAll();
-        }
-      }
-    }
-  }
-});
-async function flushAll(timeoutInMs = 1e4) {
-  const now = performance.now();
-  console.log(`Flushing at ${now}`);
-  await Promise.all([flushUsage(), flushTracingSDK()]);
-  const duration = performance.now() - now;
-  console.log(`Flushed in ${duration}ms`);
-}
-async function flushUsage() {
-  const now = performance.now();
-  console.log(`Flushing usage at ${now}`);
-  await prodUsageManager.flush();
-  const duration = performance.now() - now;
-  console.log(`Flushed usage in ${duration}ms`);
-}
-async function flushTracingSDK() {
-  const now = performance.now();
-  console.log(`Flushing tracingSDK at ${now}`);
-  await tracingSDK.flush();
-  const duration = performance.now() - now;
-  console.log(`Flushed tracingSDK in ${duration}ms`);
-}
-process.on("SIGTERM", async () => {
-});
-var prodRuntimeManager = new ProdRuntimeManager(zodIpc, {
-  waitThresholdInMs: parseInt(process.env.TRIGGER_RUNTIME_WAIT_THRESHOLD_IN_MS ?? "30000", 10)
-});
-runtime.setGlobalRuntimeManager(prodRuntimeManager);
-var taskMetadata = taskCatalog.getAllTaskMetadata();
-if (typeof importedConfig?.machine === "string") {
-  taskMetadata = taskMetadata.map((task) => {
-    if (typeof task.machine?.preset !== "string") {
-      return {
-        ...task,
-        machine: {
-          preset: importedConfig.machine
-        }
-      };
-    }
-    return task;
-  });
-}
-zodIpc.send("TASKS_READY", { tasks: taskMetadata }).catch((err) => {
-  if (err instanceof ZodSchemaParsedError) {
-    zodIpc.send("TASKS_FAILED_TO_PARSE", { zodIssues: err.error.issues, tasks: taskMetadata });
-  } else {
-    console.error("Failed to send TASKS_READY message", err);
-  }
-});
-process.title = "trigger-prod-worker";
-async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 20) {
-  async function _doHeartbeat() {
-    while (true) {
-      if (_isRunning && _execution) {
-        try {
-          await zodIpc.send("TASK_HEARTBEAT", { id: _execution.attempt.id });
-        } catch (err) {
-          console.error("Failed to send HEARTBEAT message", err);
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3 * intervalInSeconds));
-    }
-  }
-  await new Promise((resolve) => setTimeout(resolve, 1e3 * initialDelayInSeconds));
-  return _doHeartbeat();
-}
-asyncHeartbeat(5).catch((err) => {
-  console.error("Failed to start asyncHeartbeat", err);
-});

package/dist/workers/prod/worker-setup.js

@@ -1,24 +0,0 @@
-// package.json
-var version = "0.0.0-v3-prerelease-20240813130521";
-
-// src/workers/prod/worker-setup.ts
-import { taskCatalog } from "@trigger.dev/core/v3";
-import {
-  TracingSDK,
-  StandardTaskCatalog
-} from "@trigger.dev/core/v3/workers";
-__SETUP_IMPORTED_PROJECT_CONFIG__;
-var tracingSDK = new TracingSDK({
-  url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
-  instrumentations: setupImportedConfig?.instrumentations ?? [],
-  diagLogLevel: process.env.OTEL_LOG_LEVEL ?? "none",
-  forceFlushTimeoutMillis: process.env.OTEL_FORCE_FLUSH_TIMEOUT ? parseInt(process.env.OTEL_FORCE_FLUSH_TIMEOUT, 10) : 5e3
-});
-var otelTracer = tracingSDK.getTracer("trigger-prod-worker", version);
-var otelLogger = tracingSDK.getLogger("trigger-prod-worker", version);
-taskCatalog.setGlobalTaskCatalog(new StandardTaskCatalog());
-export {
-  otelLogger,
-  otelTracer,
-  tracingSDK
-};