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

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 };