@diia-inhouse/workflow 3.2.6 → 3.3.0

package/dist/interceptors/activityTraceLogAttributes.js

@@ -0,0 +1,26 @@
+import { activeSpanContext, spanContextLogAttributes } from "./spanContext.js";
+//#region src/interceptors/activityTraceLogAttributes.ts
+/**
+* Injects trace and span ids into activity log attributes.
+*
+* The SDK logs the activity lifecycle after the OpenTelemetry span has ended, so the inbound hook
+* remembers the span context while it is still active and `getLogAttributes` falls back to it.
+* `Activity started` precedes the chain entirely and stays untraced.
+*/
+var ActivityTraceLogAttributesInterceptor = class {
+	capturedSpanContext;
+	async execute(input, next) {
+		this.capturedSpanContext = activeSpanContext() ?? this.capturedSpanContext;
+		return await next(input);
+	}
+	getLogAttributes(input, next) {
+		const spanContext = activeSpanContext() ?? this.capturedSpanContext;
+		if (!spanContext) return next(input);
+		return next({
+			...spanContextLogAttributes(spanContext),
+			...input
+		});
+	}
+};
+//#endregion
+export { ActivityTraceLogAttributesInterceptor };

package/dist/interceptors/spanContext.js

@@ -0,0 +1,19 @@
+import * as otel from "@opentelemetry/api";
+//#region src/interceptors/spanContext.ts
+/** Span context of the active span, if any. */
+function activeSpanContext() {
+	const spanContext = otel.trace.getSpan(otel.context.active())?.spanContext();
+	return spanContext && otel.isSpanContextValid(spanContext) ? spanContext : void 0;
+}
+/** Trace log attributes, in both the Temporal SDK and the diia naming. */
+function spanContextLogAttributes(spanContext) {
+	return {
+		trace_id: spanContext.traceId,
+		span_id: spanContext.spanId,
+		trace_flags: `0${spanContext.traceFlags.toString(16)}`,
+		traceId: spanContext.traceId,
+		spanId: spanContext.spanId
+	};
+}
+//#endregion
+export { activeSpanContext, spanContextLogAttributes };

package/dist/interceptors/traceLogAttributes.js

@@ -1,17 +1,27 @@
-import * as otel from "@opentelemetry/api";
+import { activeSpanContext, spanContextLogAttributes } from "./spanContext.js";
 //#region src/interceptors/traceLogAttributes.ts
-/** Injects traceId and spanId from OpenTelemetry into workflow log attributes. */
+/** Injects trace and span ids into workflow log attributes. */
 var TraceLogAttributesInterceptor = class {
+	capturedSpanContext;
+	async execute(input, next) {
+		this.capturedSpanContext = activeSpanContext() ?? this.capturedSpanContext;
+		return await next(input);
+	}
 	getLogAttributes(input, next) {
-		const attrs = next(input);
-		const spanContext = otel.trace.getSpan(otel.context.active())?.spanContext();
-		if (spanContext && otel.isSpanContextValid(spanContext)) {
-			attrs.traceId = spanContext.traceId;
-			attrs.spanId = spanContext.spanId;
-		}
-		return attrs;
+		const spanContext = activeSpanContext() ?? this.capturedSpanContext;
+		if (!spanContext) return next(input);
+		return next({
+			...spanContextLogAttributes(spanContext),
+			...input
+		});
 	}
 };
-const interceptors = () => ({ outbound: [new TraceLogAttributesInterceptor()] });
+const interceptors = () => {
+	const interceptor = new TraceLogAttributesInterceptor();
+	return {
+		inbound: [interceptor],
+		outbound: [interceptor]
+	};
+};
 //#endregion
 export { interceptors };

package/dist/services/worker/runtimeLogger.js

@@ -0,0 +1,36 @@
+//#region src/services/worker/runtimeLogger.ts
+const ERROR_META_KEY = "error";
+const NORMALIZED_ERROR_META_KEY = "err";
+function normalizeMeta(meta) {
+	if (!meta || !(ERROR_META_KEY in meta) || NORMALIZED_ERROR_META_KEY in meta) return meta;
+	const { [ERROR_META_KEY]: error, ...rest } = meta;
+	return {
+		...rest,
+		[NORMALIZED_ERROR_META_KEY]: error
+	};
+}
+/**
+* Adapts a diia `Logger` to the Temporal runtime `Logger`.
+*
+* Remaps failures to the `err` key the diia logger serializes, and implements the
+* level-first `log()` signature the two interfaces disagree on.
+*/
+function toTemporalRuntimeLogger(logger) {
+	const levels = {
+		TRACE: (message, meta) => logger.trace(message, meta),
+		DEBUG: (message, meta) => logger.debug(message, meta),
+		INFO: (message, meta) => logger.info(message, meta),
+		WARN: (message, meta) => logger.warn(message, meta),
+		ERROR: (message, meta) => logger.error(message, meta)
+	};
+	return {
+		log: (level, message, meta) => levels[level]?.(message, normalizeMeta(meta)),
+		trace: (message, meta) => levels.TRACE(message, normalizeMeta(meta)),
+		debug: (message, meta) => levels.DEBUG(message, normalizeMeta(meta)),
+		info: (message, meta) => levels.INFO(message, normalizeMeta(meta)),
+		warn: (message, meta) => levels.WARN(message, normalizeMeta(meta)),
+		error: (message, meta) => levels.ERROR(message, normalizeMeta(meta))
+	};
+}
+//#endregion
+export { toTemporalRuntimeLogger };

package/dist/services/worker.d.ts

@@ -4,7 +4,7 @@ import { WorkerHealthDetails, WorkerHealthService } from "./workerHealth.js";
 import { buildWorkerIdentity } from "./worker/identity.js";
 import { EnvService } from "@diia-inhouse/env";
 import { AlsData, Logger } from "@diia-inhouse/types";
-import { Worker, WorkerOptions } from "@temporalio/worker";
+import { Worker, WorkerInterceptors, WorkerOptions } from "@temporalio/worker";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/services/worker.d.ts
@@ -31,6 +31,7 @@ declare function applyWorkerProcessConfig(config: AppConfig): void;
 * and returns a filesystem path suitable for Temporal's worker.
 */
 declare function toWorkflowsPath(input: string): string;
+declare function buildWorkerInterceptors(tracingEnabled: boolean, asyncLocalStorage: AsyncLocalStorage<AlsData> | undefined, logger: Logger | undefined, workflowsPath: string | undefined): WorkerInterceptors | undefined;
 declare function instantiateActivities(app: App, workerActivities: Record<string, ActivityClass>): Record<string, (...args: unknown[]) => Promise<unknown>>;
 /**
 * Runs the Temporal worker in the **dedicated worker process**.
@@ -131,4 +132,4 @@ declare function initWorker({
   service?: string;
 }, envService: EnvService, logger?: Logger, nodeTracerProvider?: NodeTracerProviderLike, asyncLocalStorage?: AsyncLocalStorage<AlsData>): Promise<Worker>;
 //#endregion
-export { type ActivityClass, type App, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, type WorkerBootstrapOptions, type WorkerHealthDetails, WorkerHealthService, type WorkerRunOptions, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };
+export { type ActivityClass, type App, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, type WorkerBootstrapOptions, type WorkerHealthDetails, WorkerHealthService, type WorkerRunOptions, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, buildWorkerInterceptors, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };

package/dist/services/worker.js

@@ -1,9 +1,11 @@
 import { getDataConverter } from "../encryption/dataConverter.js";
 import "../encryption/index.js";
 import { traceExporter } from "../instrumentation.js";
+import { ActivityTraceLogAttributesInterceptor } from "../interceptors/activityTraceLogAttributes.js";
 import { AsyncLocalStorageBridgeInterceptor } from "../interceptors/asyncLocalStorageBridge.js";
 import { buildWorkerIdentity } from "./worker/identity.js";
 import { deriveWorkflowTypes, registerWorkerInfo } from "./worker/info.js";
+import { toTemporalRuntimeLogger } from "./worker/runtimeLogger.js";
 import { WorkerHealthService } from "./workerHealth.js";
 import { EnvService } from "@diia-inhouse/env";
 import { NativeConnection, Runtime, Worker } from "@temporalio/worker";
@@ -58,17 +60,30 @@ function toWorkflowsPath(input) {
 /**
 * Builds worker interceptors with OpenTelemetry and AsyncLocalStorage support.
 * OpenTelemetry creates span first, then AsyncLocalStorage bridge extracts traceId.
+*
+* Order matters: the first factory is the outermost, so the ones after it see an open span.
 */
 const traceLogAttributesModulePath = path.resolve(import.meta.dirname, "../interceptors/traceLogAttributes");
+function traceLogAttributesInterceptor() {
+	const interceptor = new ActivityTraceLogAttributesInterceptor();
+	return {
+		inbound: interceptor,
+		outbound: interceptor
+	};
+}
 function buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, workflowsPath) {
 	if (tracingEnabled) {
 		const workflowModules = [traceLogAttributesModulePath];
 		if (workflowsPath) workflowModules.unshift(workflowsPath);
 		return {
-			activity: [(ctx) => ({
-				inbound: new OpenTelemetryActivityInboundInterceptor(ctx),
-				outbound: new OpenTelemetryActivityOutboundInterceptor(ctx)
-			}), ...asyncLocalStorage && logger ? [(ctx) => ({ inbound: new AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger) })] : []],
+			activity: [
+				(ctx) => ({
+					inbound: new OpenTelemetryActivityInboundInterceptor(ctx),
+					outbound: new OpenTelemetryActivityOutboundInterceptor(ctx)
+				}),
+				traceLogAttributesInterceptor,
+				...asyncLocalStorage && logger ? [(ctx) => ({ inbound: new AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger) })] : []
+			],
 			workflowModules
 		};
 	}
@@ -76,7 +91,7 @@ function buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, work
 		activity: [(ctx) => ({
 			inbound: new AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger),
 			outbound: new OpenTelemetryActivityOutboundInterceptor(ctx)
-		})],
+		}), traceLogAttributesInterceptor],
 		workflowModules: workflowsPath ? [workflowsPath] : []
 	};
 }
@@ -277,7 +292,7 @@ function tryResolve(container, key) {
 async function initWorker({ temporal: temporalConfig, metrics: { custom: metricsConfig } }, options, envService, logger, nodeTracerProvider, asyncLocalStorage) {
 	const { encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, namespace = "default", address, taskQueue } = temporalConfig;
 	const runtimeParams = {};
-	if (logger) runtimeParams.logger = logger.child({ taskQueue });
+	if (logger) runtimeParams.logger = toTemporalRuntimeLogger(logger.child({ taskQueue }));
 	const temporalMetrics = metricsConfig.scrapers?.find((s) => s.name === "temporal");
 	if (temporalMetrics && !temporalMetrics.disabled) runtimeParams.telemetryOptions = { metrics: { prometheus: {
 		bindAddress: `0.0.0.0:${temporalMetrics.port}`,
@@ -321,4 +336,4 @@ async function initWorker({ temporal: temporalConfig, metrics: { custom: metrics
 	}
 }
 //#endregion
-export { WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };
+export { WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, buildWorkerInterceptors, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };

package/dist/worker.d.ts

@@ -2,7 +2,7 @@ import { workflowInterceptors } from "./interceptors.js";
 import { ActivityClass, App, RunInProcessWorkerOptions, RunStandaloneWorkerOptions, WorkerBootstrapOptions, WorkerRunOptions } from "./interfaces/services/worker.js";
 import { WorkerHealthDetails, WorkerHealthService } from "./services/workerHealth.js";
 import { buildWorkerIdentity } from "./services/worker/identity.js";
-import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
+import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerInterceptors, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
 import { RegisterWorkerInfoParams, WORKER_INFO_METRIC, WorkerInfoLabels, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService } from "./services/worker/info.js";
 import { NativeConnection, NativeConnectionPlugin, Runtime, State, Worker, WorkerDeploymentOptions, WorkerInterceptors, WorkerOptions, WorkerPlugin, WorkerStatus, bundleWorkflowCode } from "@temporalio/worker";
-export { type ActivityClass, type App, NativeConnection, type NativeConnectionPlugin, RegisterWorkerInfoParams, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, Runtime, type State, WORKER_INFO_METRIC, Worker, type WorkerBootstrapOptions, type WorkerDeploymentOptions, type WorkerHealthDetails, WorkerHealthService, WorkerInfoLabels, type WorkerInterceptors, type WorkerOptions, type WorkerPlugin, type WorkerRunOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };
+export { type ActivityClass, type App, NativeConnection, type NativeConnectionPlugin, RegisterWorkerInfoParams, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, Runtime, type State, WORKER_INFO_METRIC, Worker, type WorkerBootstrapOptions, type WorkerDeploymentOptions, type WorkerHealthDetails, WorkerHealthService, WorkerInfoLabels, type WorkerInterceptors, type WorkerOptions, type WorkerPlugin, type WorkerRunOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, buildWorkerInterceptors, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/dist/worker.js

@@ -2,6 +2,6 @@ import { workflowInterceptors } from "./interceptors.js";
 import { buildWorkerIdentity } from "./services/worker/identity.js";
 import { WORKER_INFO_METRIC, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService } from "./services/worker/info.js";
 import { WorkerHealthService } from "./services/workerHealth.js";
-import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
+import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerInterceptors, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
 import { NativeConnection, Runtime, Worker, bundleWorkflowCode } from "@temporalio/worker";
-export { NativeConnection, Runtime, WORKER_INFO_METRIC, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };
+export { NativeConnection, Runtime, WORKER_INFO_METRIC, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, buildWorkerInterceptors, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/workflow",
-    "version": "3.2.6",
+    "version": "3.3.0",
     "description": "Workflow",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",