@proompteng/temporal-bun-sdk 0.3.0 → 0.4.0

package/dist/src/worker/runtime.js

@@ -6,10 +6,11 @@ import { Cause, Effect, Exit, Fiber } from 'effect';
 import { makeActivityLifecycle, } from '../activities/lifecycle';
 import { buildTransportOptions, normalizeTemporalAddress } from '../client';
 import { durationFromMillis, durationToMillis } from '../common/duration';
-import { createDefaultDataConverter, decodePayloadsToValues, encodeValuesToPayloads, } from '../common/payloads/converter';
+import { buildCodecsFromConfig, createDefaultDataConverter, decodePayloadsToValues, encodeValuesToPayloads, } from '../common/payloads/converter';
 import { encodeErrorToFailure, encodeFailurePayloads, failureToError } from '../common/payloads/failure';
 import { sleep } from '../common/sleep';
 import { loadTemporalConfig } from '../config';
+import { makeDefaultWorkerInterceptors, runWorkerInterceptors, } from '../interceptors/worker';
 import { createObservabilityServices } from '../observability';
 import { CommandSchema, RecordMarkerCommandAttributesSchema, } from '../proto/temporal/api/command/v1/message_pb';
 import { PayloadsSchema, WorkflowExecutionSchema, } from '../proto/temporal/api/common/v1/message_pb';
@@ -66,7 +67,6 @@ const COMPLETION_COMMAND_TYPES = new Set([
 export class WorkerRuntime {
     static async create(options = {}) {
         const config = options.config ?? (await loadTemporalConfig());
-        const dataConverter = options.dataConverter ?? createDefaultDataConverter();
         const namespace = options.namespace ?? config.namespace;
         if (!namespace) {
             throw new Error('Temporal namespace must be provided');
@@ -80,12 +80,6 @@ export class WorkerRuntime {
         if (workflows.length === 0) {
             throw new Error('No workflow definitions were registered; provide workflows or workflowsPath');
         }
-        const registry = new WorkflowRegistry();
-        registry.registerMany(workflows);
-        const executor = new WorkflowExecutor({
-            registry,
-            dataConverter,
-        });
         const activities = options.activities ?? {};
         const observability = await Effect.runPromise(createObservabilityServices({
             logLevel: config.logLevel,
@@ -97,6 +91,18 @@ export class WorkerRuntime {
             metricsExporter: options.metricsExporter,
         }));
         const { logger, metricsRegistry, metricsExporter } = observability;
+        const dataConverter = options.dataConverter ??
+            createDefaultDataConverter({
+                payloadCodecs: buildCodecsFromConfig(config.payloadCodecs),
+                logger,
+                metricsRegistry,
+            });
+        const registry = new WorkflowRegistry();
+        registry.registerMany(workflows);
+        const executor = new WorkflowExecutor({
+            registry,
+            dataConverter,
+        });
         const runtimeMetrics = await WorkerRuntime.#initMetrics(metricsRegistry);
         let workflowService;
         if (options.workflowService) {
@@ -181,6 +187,22 @@ export class WorkerRuntime {
                 }));
             }
         }
+        const tracingEnabled = options.tracingEnabled ?? config.tracingInterceptorsEnabled ?? false;
+        const workerInterceptorBuilder = options.interceptorBuilder ?? {
+            build: (input) => makeDefaultWorkerInterceptors(input),
+        };
+        const defaultWorkerInterceptors = await Effect.runPromise(workerInterceptorBuilder.build({
+            namespace,
+            taskQueue,
+            identity,
+            buildId,
+            logger,
+            metricsRegistry,
+            metricsExporter,
+            dataConverter,
+            tracingEnabled,
+        }));
+        const workerInterceptors = [...defaultWorkerInterceptors, ...(options.interceptors ?? [])];
         const activityLifecycle = await Effect.runPromise(makeActivityLifecycle({
             heartbeatIntervalMs: config.activityHeartbeatIntervalMs,
             heartbeatRpcTimeoutMs: config.activityHeartbeatRpcTimeoutMs,
@@ -233,6 +255,7 @@ export class WorkerRuntime {
             versioningBehavior,
             stickySchedulingEnabled,
             workflowPollerCount,
+            interceptors: workerInterceptors,
         });
     }
     #config;
@@ -248,6 +271,7 @@ export class WorkerRuntime {
     #namespace;
     #taskQueue;
     #identity;
+    #interceptors;
     #activityLifecycle;
     #scheduler;
     #stickyCache;
@@ -275,6 +299,7 @@ export class WorkerRuntime {
         this.#namespace = params.namespace;
         this.#taskQueue = params.taskQueue;
         this.#identity = params.identity;
+        this.#interceptors = params.interceptors;
         this.#activityLifecycle = params.activityLifecycle;
         this.#scheduler = params.scheduler;
         this.#stickyCache = params.stickyCache;
@@ -353,6 +378,10 @@ export class WorkerRuntime {
             workflowTaskCompleted: await makeCounter('temporal_worker_workflow_tasks_completed_total', 'Workflow tasks completed by the scheduler'),
             activityTaskStarted: await makeCounter('temporal_worker_activity_tasks_started_total', 'Activity tasks dispatched to the scheduler'),
             activityTaskCompleted: await makeCounter('temporal_worker_activity_tasks_completed_total', 'Activity tasks completed by the scheduler'),
+            queryTaskStarted: await makeCounter('temporal_worker_query_started_total', 'Query-only workflow tasks dispatched to the scheduler'),
+            queryTaskCompleted: await makeCounter('temporal_worker_query_completed_total', 'Query-only workflow tasks completed successfully'),
+            queryTaskFailed: await makeCounter('temporal_worker_query_failed_total', 'Query-only workflow tasks responded with failure'),
+            queryTaskLatency: await makeHistogram('temporal_worker_query_latency_ms', 'End-to-end workflow query latency (ms)'),
         };
     }
     async run() {
@@ -514,17 +543,38 @@ export class WorkerRuntime {
     #isRpcAbortError(error) {
         return isAbortError(error) || (error instanceof ConnectError && error.code === Code.Canceled);
     }
+    #isBenignPollTimeout(error) {
+        if (error instanceof ConnectError) {
+            return error.code === Code.DeadlineExceeded || error.code === Code.Canceled;
+        }
+        if (error instanceof Error) {
+            const msg = error.message.toLowerCase();
+            return msg.includes('deadline') && msg.includes('exceeded');
+        }
+        if (typeof error === 'string') {
+            const msg = error.toLowerCase();
+            return msg.includes('deadline') && msg.includes('exceeded');
+        }
+        return false;
+    }
     async #enqueueActivityTask(response) {
         const taskToken = response.taskToken ?? new Uint8Array();
         const envelope = {
             taskToken,
-            handler: () => this.#processActivityTask(response),
+            handler: () => this.#runActivityTask(response),
             args: [],
         };
         await Effect.runPromise(this.#scheduler.enqueueActivity(envelope));
     }
     #handleWorkflowPollerError(queueName, error) {
         return Effect.promise(async () => {
+            if (this.#isBenignPollTimeout(error)) {
+                this.#log('debug', 'workflow poll timeout (no tasks)', {
+                    queueName,
+                    namespace: this.#namespace,
+                });
+                return;
+            }
             this.#incrementCounter(this.#metrics.workflowPollErrors);
             this.#log('warn', 'workflow polling failed', {
                 queueName,
@@ -536,6 +586,13 @@ export class WorkerRuntime {
     }
     #handleActivityPollerError(error) {
         return Effect.promise(async () => {
+            if (this.#isBenignPollTimeout(error)) {
+                this.#log('debug', 'activity poll timeout (no tasks)', {
+                    namespace: this.#namespace,
+                    taskQueue: this.#taskQueue,
+                });
+                return;
+            }
             this.#incrementCounter(this.#metrics.activityPollErrors);
             this.#log('warn', 'activity polling failed', {
                 namespace: this.#namespace,
@@ -547,7 +604,40 @@ export class WorkerRuntime {
     }
     async #handleWorkflowTask(response, nondeterminismRetry = 0) {
         const execution = this.#resolveWorkflowExecution(response);
+        const queryCount = response.queries && typeof response.queries === 'object' && !Array.isArray(response.queries)
+            ? Object.keys(response.queries).length
+            : Array.isArray(response.queries)
+                ? response.queries.length
+                : 0;
+        const hasQueryRequests = Boolean(response.query) || queryCount > 0;
+        const hasUpdateMessages = (response.messages?.length ?? 0) > 0;
+        const kind = hasUpdateMessages
+            ? 'worker.updateTask'
+            : hasQueryRequests
+                ? 'worker.queryTask'
+                : 'worker.workflowTask';
+        const context = {
+            kind,
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            identity: this.#identity,
+            buildId: this.#deploymentOptions.buildId,
+            workflowId: execution.workflowId,
+            runId: execution.runId,
+            attempt: Number(response.attempt ?? 1),
+            metadata: { nondeterminismRetry },
+        };
+        const effect = runWorkerInterceptors(this.#interceptors, context, () => Effect.tryPromise(() => this.#processWorkflowTask(response, nondeterminismRetry, execution)));
+        await Effect.runPromise(effect);
+    }
+    async #processWorkflowTask(response, nondeterminismRetry = 0, executionOverride) {
+        const execution = executionOverride ?? this.#resolveWorkflowExecution(response);
         const workflowTaskAttempt = Number(response.attempt ?? 1);
+        const isLegacyQueryTask = Boolean(response.query);
+        const queryStartTime = isLegacyQueryTask ? Date.now() : null;
+        if (isLegacyQueryTask) {
+            this.#incrementCounter(this.#metrics.queryTaskStarted);
+        }
         const historyEvents = await this.#collectWorkflowHistory(execution, response);
         const workflowType = this.#resolveWorkflowType(response, historyEvents);
         const args = await this.#decodeWorkflowArgs(historyEvents);
@@ -637,7 +727,8 @@ export class WorkerRuntime {
         }
         const expectedDeterminismState = previousState;
         try {
-            const activityResults = await this.#extractActivityResolutions(historyEvents);
+            const { results: activityResults, scheduledEventIds: activityScheduleEventIds } = await this.#extractActivityResolutions(historyEvents);
+            const timerResults = await this.#extractTimerResolutions(historyEvents);
             const replayUpdates = historyReplay?.updates ?? [];
             const mergedUpdates = mergeUpdateInvocations(replayUpdates, collectedUpdates.invocations);
             const output = await this.#executor.execute({
@@ -649,9 +740,12 @@ export class WorkerRuntime {
                 arguments: args,
                 determinismState: previousState,
                 activityResults,
+                activityScheduleEventIds,
                 signalDeliveries,
+                timerResults,
                 queryRequests,
                 updates: mergedUpdates,
+                mode: isLegacyQueryTask ? 'query' : 'workflow',
             });
             this.#log('debug', 'workflow query evaluation summary', {
                 ...baseLogFields,
@@ -681,10 +775,28 @@ export class WorkerRuntime {
                     legacyQueryResult = entry;
                 }
             }
+            if (isLegacyQueryTask) {
+                const target = legacyQueryResult ?? output.queryResults.find((entry) => entry.request.source === 'legacy');
+                if (!target) {
+                    throw new Error('Legacy query result missing from workflow execution');
+                }
+                await this.#respondLegacyQueryTask(response, target);
+                if (queryStartTime !== null) {
+                    this.#observeHistogram(this.#metrics.queryTaskLatency, Date.now() - queryStartTime);
+                }
+                this.#incrementCounter(this.#metrics.queryTaskCompleted);
+                return;
+            }
             const cacheBaselineEventId = this.#resolveCurrentStartedEventId(response) ?? historyReplay?.lastEventId ?? null;
             const shouldRecordMarker = output.completion === 'pending';
             let commandsForResponse = output.commands;
-            const dispatchesForNewMessages = (output.updateDispatches ?? []).filter((dispatch) => collectedUpdates.requestsByUpdateId.has(dispatch.updateId));
+            const dispatchesForNewMessages = (output.updateDispatches ?? []).filter((dispatch) => {
+                if (dispatch.type === 'acceptance' || dispatch.type === 'rejection') {
+                    return collectedUpdates.requestsByUpdateId.has(dispatch.updateId);
+                }
+                // Allow completion messages to be emitted even if the request metadata was seen on a prior task.
+                return true;
+            });
             const updateProtocolMessages = await buildUpdateProtocolMessages({
                 dispatches: dispatchesForNewMessages,
                 collected: collectedUpdates,
@@ -702,6 +814,7 @@ export class WorkerRuntime {
                 }
                 else {
                     await this.#removeStickyEntry(stickyKey);
+                    await this.#removeStickyEntriesForWorkflow(stickyKey.workflowId);
                     this.#log('debug', 'sticky cache entry cleared (workflow completed)', baseLogFields);
                 }
             }
@@ -754,12 +867,29 @@ export class WorkerRuntime {
             let stickyEntryCleared = false;
             if (stickyKey) {
                 await this.#removeStickyEntry(stickyKey);
+                await this.#removeStickyEntriesForWorkflow(stickyKey.workflowId);
                 stickyEntryCleared = true;
             }
             if (this.#isTaskNotFoundError(error)) {
                 this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
                 return;
             }
+            if (isLegacyQueryTask) {
+                this.#incrementCounter(this.#metrics.queryTaskFailed);
+                if (queryStartTime !== null) {
+                    this.#observeHistogram(this.#metrics.queryTaskLatency, Date.now() - queryStartTime);
+                }
+                if (error instanceof WorkflowNondeterminismError) {
+                    const mismatches = await this.#computeNondeterminismMismatches(error, expectedDeterminismState);
+                    this.#incrementCounter(this.#metrics.nondeterminism);
+                    this.#log('error', 'workflow query nondeterminism detected', {
+                        ...baseLogFields,
+                        mismatches,
+                    });
+                }
+                await this.#respondLegacyQueryFailure(response, error);
+                return;
+            }
             if (error instanceof WorkflowNondeterminismError) {
                 const mismatches = await this.#computeNondeterminismMismatches(error, expectedDeterminismState);
                 if (stickyKey && stickyEntryCleared) {
@@ -838,6 +968,7 @@ export class WorkerRuntime {
     async #extractActivityResolutions(events) {
         const resolutions = new Map();
         const scheduledActivityIds = new Map();
+        const activityScheduleById = new Map();
         const normalizeEventId = (value) => {
             if (value === undefined || value === null) {
                 return undefined;
@@ -868,6 +999,7 @@ export class WorkerRuntime {
                     const scheduledKey = normalizeEventId(event.eventId);
                     if (activityId && scheduledKey) {
                         scheduledActivityIds.set(scheduledKey, activityId);
+                        activityScheduleById.set(activityId, scheduledKey);
                     }
                     break;
                 }
@@ -932,7 +1064,7 @@ export class WorkerRuntime {
                     break;
             }
         }
-        return resolutions;
+        return { results: resolutions, scheduledEventIds: activityScheduleById };
     }
     async #extractSignalDeliveries(events) {
         const deliveries = [];
@@ -970,6 +1102,22 @@ export class WorkerRuntime {
         }
         return deliveries;
     }
+    async #extractTimerResolutions(events) {
+        const fired = new Set();
+        for (const event of events) {
+            if (event.eventType !== EventType.TIMER_FIRED) {
+                continue;
+            }
+            if (event.attributes?.case !== 'timerFiredEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            if (attrs.timerId) {
+                fired.add(attrs.timerId);
+            }
+        }
+        return fired;
+    }
     async #extractWorkflowQueryRequests(response) {
         const requests = [];
         const map = response.queries ?? {};
@@ -1035,6 +1183,34 @@ export class WorkerRuntime {
         });
         await this.#workflowService.respondQueryTaskCompleted(request, { timeoutMs: RESPOND_TIMEOUT_MS });
     }
+    async #respondLegacyQueryFailure(response, cause) {
+        const failure = await encodeErrorToFailure(this.#dataConverter, cause);
+        const message = cause instanceof Error ? cause.message : 'Workflow query failed';
+        const request = create(RespondQueryTaskCompletedRequestSchema, {
+            taskToken: response.taskToken ?? new Uint8Array(),
+            completedType: QueryResultType.FAILED,
+            errorMessage: message,
+            namespace: this.#namespace,
+            failure,
+            cause: WorkflowTaskFailedCause.UNSPECIFIED,
+        });
+        try {
+            await this.#workflowService.respondQueryTaskCompleted(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+        }
+        catch (rpcError) {
+            this.#log('error', 'respondQueryTaskCompleted failed for legacy query', {
+                namespace: this.#namespace,
+                workflowId: response.workflowExecution?.workflowId,
+                runId: response.workflowExecution?.runId,
+                error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+            });
+            if (this.#isTaskNotFoundError(rpcError)) {
+                this.#logWorkflowTaskNotFound('respondQueryTaskCompleted', this.#resolveWorkflowExecution(response));
+                return;
+            }
+            throw rpcError;
+        }
+    }
     async #fetchWorkflowHistoryPage(execution, nextPageToken) {
         if (!execution.workflowId || !execution.runId) {
             return { events: [], nextPageToken: new Uint8Array() };
@@ -1316,6 +1492,11 @@ export class WorkerRuntime {
     async #removeStickyEntry(key) {
         await Effect.runPromise(this.#stickyCache.remove(key));
     }
+    async #removeStickyEntriesForWorkflow(workflowId) {
+        if (!workflowId)
+            return;
+        await Effect.runPromise(this.#stickyCache.removeByWorkflow({ namespace: this.#namespace, workflowId }));
+    }
     async #failWorkflowTask(response, execution, error, cause = WorkflowTaskFailedCause.UNSPECIFIED) {
         const failure = await encodeErrorToFailure(this.#dataConverter, error);
         const encoded = await encodeFailurePayloads(this.#dataConverter, failure);
@@ -1339,6 +1520,20 @@ export class WorkerRuntime {
             throw rpcError;
         }
     }
+    async #runActivityTask(response) {
+        const context = {
+            kind: 'worker.activityTask',
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            identity: this.#identity,
+            buildId: this.#deploymentOptions.buildId,
+            workflowId: response.workflowExecution?.workflowId ?? undefined,
+            runId: response.workflowExecution?.runId ?? undefined,
+            attempt: Number(response.attempt ?? 1),
+        };
+        const effect = runWorkerInterceptors(this.#interceptors, context, () => Effect.tryPromise(() => this.#processActivityTask(response)));
+        await Effect.runPromise(effect);
+    }
     async #processActivityTask(response) {
         const cancelRequested = isActivityCancelRequested(response);
         if (cancelRequested) {