@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/v3/utils/timers.mjs

@@ -0,0 +1,28 @@
+import { setTimeout, setInterval } from 'node:timers/promises';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function unboundedTimeout(delay = 0, value, options) {
+  const maxDelay = 2147483647;
+  const fullTimeouts = Math.floor(delay / maxDelay);
+  const remainingDelay = delay % maxDelay;
+  let lastTimeoutResult = await setTimeout(remainingDelay, value, options);
+  for (let i = 0; i < fullTimeouts; i++) {
+    lastTimeoutResult = await setTimeout(maxDelay, value, options);
+  }
+  return lastTimeoutResult;
+}
+__name(unboundedTimeout, "unboundedTimeout");
+async function checkpointSafeTimeout(delay = 0) {
+  const scanIntervalMs = 1e3;
+  for await (const start of setInterval(scanIntervalMs, Date.now())) {
+    if (Date.now() - start > delay) {
+      break;
+    }
+  }
+}
+__name(checkpointSafeTimeout, "checkpointSafeTimeout");
+
+export { checkpointSafeTimeout, unboundedTimeout };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=timers.mjs.map

package/dist/v3/utils/timers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/v3/utils/timers.ts"],"names":["setInterval","setTimeout","unboundedTimeout","delay","value","options","maxDelay","fullTimeouts","Math","floor","remainingDelay","lastTimeoutResult","i","checkpointSafeTimeout","scanIntervalMs","start","Date","now"],"mappings":";;;;AAAA,SAASA,aAAaC,kBAAkB;AAExC,eAAsBC,iBACpBC,QAAgB,GAChBC,OACAC,SACY;AACZ,QAAMC,WAAW;AAEjB,QAAMC,eAAeC,KAAKC,MAAMN,QAAQG,QAAAA;AACxC,QAAMI,iBAAiBP,QAAQG;AAE/B,MAAIK,oBAAoB,MAAMV,WAAWS,gBAAgBN,OAAOC,OAAAA;AAEhE,WAASO,IAAI,GAAGA,IAAIL,cAAcK,KAAK;AACrCD,wBAAoB,MAAMV,WAAWK,UAAUF,OAAOC,OAAAA;EACxD;AAEA,SAAOM;AACT;AAjBsBT;AAmBtB,eAAsBW,sBAAsBV,QAAgB,GAAkB;AAC5E,QAAMW,iBAAiB;AAGvB,mBAAiBC,SAASf,YAAYc,gBAAgBE,KAAKC,IAAG,CAAA,GAAK;AACjE,QAAID,KAAKC,IAAG,IAAKF,QAAQZ,OAAO;AAC9B;IACF;EACF;AACF;AATsBU","sourcesContent":["import { setInterval, setTimeout } from \"node:timers/promises\";\n\nexport async function unboundedTimeout<T = void>(\n  delay: number = 0,\n  value?: T,\n  options?: Parameters<typeof setTimeout>[2]\n): Promise<T> {\n  const maxDelay = 2147483647; // Highest value that will fit in a 32-bit signed integer\n\n  const fullTimeouts = Math.floor(delay / maxDelay);\n  const remainingDelay = delay % maxDelay;\n\n  let lastTimeoutResult = await setTimeout(remainingDelay, value, options);\n\n  for (let i = 0; i < fullTimeouts; i++) {\n    lastTimeoutResult = await setTimeout(maxDelay, value, options);\n  }\n\n  return lastTimeoutResult;\n}\n\nexport async function checkpointSafeTimeout(delay: number = 0): Promise<void> {\n  const scanIntervalMs = 1000;\n\n  // Every scanIntervalMs, check if delay has elapsed\n  for await (const start of setInterval(scanIntervalMs, Date.now())) {\n    if (Date.now() - start > delay) {\n      break;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,144 @@
+import * as logsAPI from '@opentelemetry/api-logs';
+import { TracingSDK } from '../otel/index.mjs';
+export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.mjs';
+import { c as TaskRunExecution, T as TaskRunExecutionResult } from '../../common-CLW82lkt.mjs';
+import { B as BackgroundWorkerProperties } from '../../messages-JvHJ83wv.mjs';
+import { C as Config, a as TaskFileMetadata, b as TaskMetadataWithFilePath } from '../../schemas-C9ssfehv.mjs';
+import { P as ProjectConfig, H as HandleErrorFunction, T as TaskMetadataWithFunctions, U as UsageMeasurement, C as Clock, a as ClockTime, b as TaskCatalog, c as UsageManager, d as UsageSample } from '../../catalog-H7yFiZ60.mjs';
+export { u as usage } from '../../catalog-H7yFiZ60.mjs';
+import { T as TriggerTracer } from '../../tracer-N0p2Fuuv.mjs';
+export { R as RuntimeManager } from '../../manager-KvCabW1a.mjs';
+import { PreciseDate } from '@google-cloud/precise-date';
+export { O as OtelTaskLogger, l as logLevels } from '../../taskLogger-r_AFTX45.mjs';
+import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
+import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';
+import { Context } from '@opentelemetry/api';
+import '@opentelemetry/instrumentation';
+import '@opentelemetry/resources';
+import 'zod';
+
+declare class ConsoleInterceptor {
+    #private;
+    private readonly logger;
+    private readonly sendToStdIO;
+    constructor(logger: logsAPI.Logger, sendToStdIO: boolean);
+    intercept<T>(console: Console, callback: () => Promise<T>): Promise<T>;
+    debug(...args: unknown[]): void;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+
+type TaskExecutorOptions = {
+    tracingSDK: TracingSDK;
+    tracer: TriggerTracer;
+    consoleInterceptor: ConsoleInterceptor;
+    projectConfig: Config;
+    importedConfig: ProjectConfig | undefined;
+    handleErrorFn: HandleErrorFunction | undefined;
+};
+declare class TaskExecutor {
+    #private;
+    task: TaskMetadataWithFunctions;
+    private _tracingSDK;
+    private _tracer;
+    private _consoleInterceptor;
+    private _config;
+    private _importedConfig;
+    private _handleErrorFn;
+    constructor(task: TaskMetadataWithFunctions, options: TaskExecutorOptions);
+    execute(execution: TaskRunExecution, worker: BackgroundWorkerProperties, traceContext: Record<string, unknown>, usage: UsageMeasurement): Promise<{
+        result: TaskRunExecutionResult;
+    }>;
+}
+
+type PreciseWallClockOptions = {
+    origin?: ClockTime;
+    now?: PreciseDate;
+};
+declare class PreciseWallClock implements Clock {
+    #private;
+    private _origin;
+    constructor(options?: PreciseWallClockOptions);
+    preciseNow(): [number, number];
+    reset(): void;
+}
+
+declare function getEnvVar(name: string): string | undefined;
+
+declare class StandardTaskCatalog implements TaskCatalog {
+    private _taskMetadata;
+    private _taskFunctions;
+    private _taskFileMetadata;
+    registerTaskMetadata(task: TaskMetadataWithFunctions): void;
+    updateTaskMetadata(id: string, updates: Partial<TaskMetadataWithFunctions>): void;
+    registerTaskFileMetadata(id: string, metadata: TaskFileMetadata): void;
+    getAllTaskMetadata(): Array<TaskMetadataWithFilePath>;
+    getTaskMetadata(id: string): TaskMetadataWithFilePath | undefined;
+    getTask(id: string): TaskMetadataWithFunctions | undefined;
+    taskExists(id: string): boolean;
+    disable(): void;
+}
+
+declare class TaskContextSpanProcessor implements SpanProcessor {
+    private _innerProcessor;
+    constructor(innerProcessor: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: Span): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+declare class TaskContextLogProcessor implements LogRecordProcessor {
+    private _innerProcessor;
+    constructor(innerProcessor: LogRecordProcessor);
+    forceFlush(): Promise<void>;
+    onEmit(logRecord: LogRecord, context?: Context | undefined): void;
+    shutdown(): Promise<void>;
+}
+
+declare class DevUsageMeasurement implements UsageMeasurement {
+    readonly id: string;
+    private startedAt;
+    private _pauses;
+    private _endedAt;
+    constructor(id: string, startedAt?: ClockTime);
+    stop(): void;
+    sample(): UsageSample;
+    registerPause(pauseId: string, start: ClockTime, end?: ClockTime): void;
+}
+declare class DevUsageManager implements UsageManager {
+    private _firstMeasurement?;
+    private _currentMeasurements;
+    private _pauses;
+    disable(): void;
+    sample(): UsageSample | undefined;
+    start(): DevUsageMeasurement;
+    stop(measurement: DevUsageMeasurement): UsageSample;
+    pauseAsync<T>(cb: () => Promise<T>): Promise<T>;
+}
+
+type ProdUsageManagerOptions = {
+    heartbeatIntervalMs?: number;
+    url?: string;
+    jwt?: string;
+};
+declare class ProdUsageManager implements UsageManager {
+    #private;
+    private readonly delegageUsageManager;
+    private readonly options;
+    private _measurement;
+    private _abortController;
+    private _lastSample;
+    private _usageClient;
+    constructor(delegageUsageManager: UsageManager, options: ProdUsageManagerOptions);
+    get isReportingEnabled(): boolean;
+    disable(): void;
+    sample(): UsageSample | undefined;
+    start(): UsageMeasurement;
+    stop(measurement: UsageMeasurement): UsageSample;
+    pauseAsync<T>(cb: () => Promise<T>): Promise<T>;
+    flush(): Promise<void>;
+}
+
+export { ConsoleInterceptor, DevUsageManager, PreciseWallClock as DurableClock, ProdUsageManager, type ProdUsageManagerOptions, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, type TaskExecutorOptions, TracingSDK, getEnvVar };

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

@@ -0,0 +1,144 @@
+import * as logsAPI from '@opentelemetry/api-logs';
+import { TracingSDK } from '../otel/index.js';
+export { TracingDiagnosticLogLevel, recordSpanException } from '../otel/index.js';
+import { c as TaskRunExecution, T as TaskRunExecutionResult } from '../../common-CLW82lkt.js';
+import { B as BackgroundWorkerProperties } from '../../messages-JvHJ83wv.js';
+import { C as Config, a as TaskFileMetadata, b as TaskMetadataWithFilePath } from '../../schemas-C9ssfehv.js';
+import { P as ProjectConfig, H as HandleErrorFunction, T as TaskMetadataWithFunctions, U as UsageMeasurement, C as Clock, a as ClockTime, b as TaskCatalog, c as UsageManager, d as UsageSample } from '../../catalog-h79CG5Wy.js';
+export { u as usage } from '../../catalog-h79CG5Wy.js';
+import { T as TriggerTracer } from '../../tracer-N0p2Fuuv.js';
+export { R as RuntimeManager } from '../../manager-OBA35PzR.js';
+import { PreciseDate } from '@google-cloud/precise-date';
+export { O as OtelTaskLogger, l as logLevels } from '../../taskLogger-CzADe4je.js';
+import { LogRecordProcessor, LogRecord } from '@opentelemetry/sdk-logs';
+import { SpanProcessor, Span } from '@opentelemetry/sdk-trace-base';
+import { Context } from '@opentelemetry/api';
+import '@opentelemetry/instrumentation';
+import '@opentelemetry/resources';
+import 'zod';
+
+declare class ConsoleInterceptor {
+    #private;
+    private readonly logger;
+    private readonly sendToStdIO;
+    constructor(logger: logsAPI.Logger, sendToStdIO: boolean);
+    intercept<T>(console: Console, callback: () => Promise<T>): Promise<T>;
+    debug(...args: unknown[]): void;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+
+type TaskExecutorOptions = {
+    tracingSDK: TracingSDK;
+    tracer: TriggerTracer;
+    consoleInterceptor: ConsoleInterceptor;
+    projectConfig: Config;
+    importedConfig: ProjectConfig | undefined;
+    handleErrorFn: HandleErrorFunction | undefined;
+};
+declare class TaskExecutor {
+    #private;
+    task: TaskMetadataWithFunctions;
+    private _tracingSDK;
+    private _tracer;
+    private _consoleInterceptor;
+    private _config;
+    private _importedConfig;
+    private _handleErrorFn;
+    constructor(task: TaskMetadataWithFunctions, options: TaskExecutorOptions);
+    execute(execution: TaskRunExecution, worker: BackgroundWorkerProperties, traceContext: Record<string, unknown>, usage: UsageMeasurement): Promise<{
+        result: TaskRunExecutionResult;
+    }>;
+}
+
+type PreciseWallClockOptions = {
+    origin?: ClockTime;
+    now?: PreciseDate;
+};
+declare class PreciseWallClock implements Clock {
+    #private;
+    private _origin;
+    constructor(options?: PreciseWallClockOptions);
+    preciseNow(): [number, number];
+    reset(): void;
+}
+
+declare function getEnvVar(name: string): string | undefined;
+
+declare class StandardTaskCatalog implements TaskCatalog {
+    private _taskMetadata;
+    private _taskFunctions;
+    private _taskFileMetadata;
+    registerTaskMetadata(task: TaskMetadataWithFunctions): void;
+    updateTaskMetadata(id: string, updates: Partial<TaskMetadataWithFunctions>): void;
+    registerTaskFileMetadata(id: string, metadata: TaskFileMetadata): void;
+    getAllTaskMetadata(): Array<TaskMetadataWithFilePath>;
+    getTaskMetadata(id: string): TaskMetadataWithFilePath | undefined;
+    getTask(id: string): TaskMetadataWithFunctions | undefined;
+    taskExists(id: string): boolean;
+    disable(): void;
+}
+
+declare class TaskContextSpanProcessor implements SpanProcessor {
+    private _innerProcessor;
+    constructor(innerProcessor: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: Span): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+declare class TaskContextLogProcessor implements LogRecordProcessor {
+    private _innerProcessor;
+    constructor(innerProcessor: LogRecordProcessor);
+    forceFlush(): Promise<void>;
+    onEmit(logRecord: LogRecord, context?: Context | undefined): void;
+    shutdown(): Promise<void>;
+}
+
+declare class DevUsageMeasurement implements UsageMeasurement {
+    readonly id: string;
+    private startedAt;
+    private _pauses;
+    private _endedAt;
+    constructor(id: string, startedAt?: ClockTime);
+    stop(): void;
+    sample(): UsageSample;
+    registerPause(pauseId: string, start: ClockTime, end?: ClockTime): void;
+}
+declare class DevUsageManager implements UsageManager {
+    private _firstMeasurement?;
+    private _currentMeasurements;
+    private _pauses;
+    disable(): void;
+    sample(): UsageSample | undefined;
+    start(): DevUsageMeasurement;
+    stop(measurement: DevUsageMeasurement): UsageSample;
+    pauseAsync<T>(cb: () => Promise<T>): Promise<T>;
+}
+
+type ProdUsageManagerOptions = {
+    heartbeatIntervalMs?: number;
+    url?: string;
+    jwt?: string;
+};
+declare class ProdUsageManager implements UsageManager {
+    #private;
+    private readonly delegageUsageManager;
+    private readonly options;
+    private _measurement;
+    private _abortController;
+    private _lastSample;
+    private _usageClient;
+    constructor(delegageUsageManager: UsageManager, options: ProdUsageManagerOptions);
+    get isReportingEnabled(): boolean;
+    disable(): void;
+    sample(): UsageSample | undefined;
+    start(): UsageMeasurement;
+    stop(measurement: UsageMeasurement): UsageSample;
+    pauseAsync<T>(cb: () => Promise<T>): Promise<T>;
+    flush(): Promise<void>;
+}
+
+export { ConsoleInterceptor, DevUsageManager, PreciseWallClock as DurableClock, ProdUsageManager, type ProdUsageManagerOptions, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, type TaskExecutorOptions, TracingSDK, getEnvVar };