@diia-inhouse/workflow 2.7.0 → 2.8.0

package/dist/interfaces/services/worker.d.ts

@@ -34,6 +34,15 @@ interface WorkerBootstrapOptions extends Omit<WorkerOptions, "taskQueue" | "acti
   nodeTracerProvider?: NodeTracerProviderLike;
   shutdownSignals?: NodeJS.Signals[];
   /**
+  * The workflows this worker runs. Recorded on the `diia_temporal_worker_info` metric.
+  *
+  * Optional — left empty, the workflows are picked up automatically from the workflows folder, so
+  * most services don't need to set this. Pass it only to override that.
+  */
+  workflowTypes?: string[];
+  /** Service name for the metric. Defaults to the name derived from the task queue. */
+  service?: string;
+  /**
   * When provided together with `deps`, `bootstrapWorker` manages the full application
   * lifecycle: setConfig → apply worker overrides → setDeps → initialize → start → run worker.
   */

package/dist/services/worker/info.d.ts

@@ -0,0 +1,29 @@
+//#region src/services/worker/info.d.ts
+declare const WORKER_INFO_METRIC = "diia_temporal_worker_info";
+interface WorkerInfoLabels {
+  namespace: string;
+  temporal_namespace: string;
+  task_queue: string;
+  service: string;
+  workflow_type: string;
+}
+declare function taskQueueToService(taskQueue: string): string;
+interface RegisterWorkerInfoParams {
+  namespace: string;
+  taskQueue: string;
+  /** Service name. Defaults to the name derived from the task queue. */
+  service?: string;
+  /** The workflows this worker runs (one entry each). Leave empty to record just the worker. */
+  workflowTypes?: string[];
+}
+declare function registerWorkerInfo({
+  namespace,
+  taskQueue,
+  service,
+  workflowTypes
+}: RegisterWorkerInfoParams): void;
+declare function deriveWorkflowTypes(workflowsPath: string, logger?: {
+  warn(message: string, meta?: unknown): void;
+}): Promise<string[] | undefined>;
+//#endregion
+export { RegisterWorkerInfoParams, WORKER_INFO_METRIC, WorkerInfoLabels, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService };

package/dist/services/worker/info.js

@@ -0,0 +1,44 @@
+import { pathToFileURL } from "node:url";
+import { Observer } from "@diia-inhouse/diia-metrics";
+//#region src/services/worker/info.ts
+const WORKER_INFO_METRIC = "diia_temporal_worker_info";
+const WORKER_INFO_LABELS = [
+	"namespace",
+	"temporal_namespace",
+	"task_queue",
+	"service",
+	"workflow_type"
+];
+function taskQueueToService(taskQueue) {
+	const trimmed = taskQueue.trim();
+	if (!trimmed) return "unknown";
+	return trimmed.replace(/[-_](worker|workers|queue)$/i, "");
+}
+function registerWorkerInfo({ namespace, taskQueue, service, workflowTypes }) {
+	if (!taskQueue) return;
+	const resolvedService = service?.trim() || taskQueueToService(taskQueue);
+	const info = new Observer(WORKER_INFO_METRIC, WORKER_INFO_LABELS, "Which namespace, task queue and workflows a service runs (always 1).");
+	const base = {
+		namespace,
+		temporal_namespace: namespace,
+		task_queue: taskQueue,
+		service: resolvedService
+	};
+	const types = workflowTypes?.length ? workflowTypes : [""];
+	for (const workflow_type of types) info.observe({
+		...base,
+		workflow_type
+	}, 1);
+}
+async function deriveWorkflowTypes(workflowsPath, logger) {
+	try {
+		const mod = await import(pathToFileURL(workflowsPath).href);
+		const types = Object.entries(mod).filter(([, value]) => typeof value === "function" && value.constructor?.name === "AsyncFunction").map(([name]) => name);
+		return types.length ? types : void 0;
+	} catch (err) {
+		logger?.warn("worker-info: could not read workflows; recording the worker without per-workflow detail", { err });
+		return;
+	}
+}
+//#endregion
+export { WORKER_INFO_METRIC, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService };

package/dist/services/worker.d.ts

@@ -66,7 +66,9 @@ declare function instantiateActivities(app: App, workerActivities: Record<string
 declare function initTemporalWorker(app: App, options: {
   nodeTracerProvider: NodeTracerProviderLike;
   workflowsPath: string;
-  activities: Record<string, ActivityClass>;
+  activities: Record<string, ActivityClass>; /** The workflows this worker runs. Auto-detected from the workflows folder when left empty. */
+  workflowTypes?: string[]; /** Service name. Defaults to the name derived from the task queue. */
+  service?: string;
 } & Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath">): Promise<void>;
 /**
 * Bootstraps and runs Temporal worker with graceful shutdown.
@@ -118,7 +120,9 @@ declare function initWorker({
     custom: metricsConfig
   }
 }: AppConfig, options: Omit<WorkerOptions, "taskQueue"> & {
-  taskQueue?: string;
+  taskQueue?: string; /** The workflows this worker runs. Auto-detected from the workflows folder when left empty. */
+  workflowTypes?: string[]; /** Service name. Defaults to the name derived from the task queue. */
+  service?: string;
 }, envService: EnvService, logger?: Logger, nodeTracerProvider?: NodeTracerProviderLike, asyncLocalStorage?: AsyncLocalStorage<AlsData>): Promise<Worker>;
 //#endregion
 export { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath };

package/dist/services/worker.js

@@ -3,6 +3,7 @@ import "../encryption/index.js";
 import { traceExporter } from "../instrumentation.js";
 import { AsyncLocalStorageBridgeInterceptor } from "../interceptors/asyncLocalStorageBridge.js";
 import { buildWorkerIdentity } from "./worker/identity.js";
+import { deriveWorkflowTypes, registerWorkerInfo } from "./worker/info.js";
 import { WorkerHealthService } from "./workerHealth.js";
 import { EnvService } from "@diia-inhouse/env";
 import { NativeConnection, Runtime, Worker } from "@temporalio/worker";
@@ -266,17 +267,29 @@ async function initWorker({ temporal: temporalConfig, metrics: { custom: metrics
 	const tracingEnabled = EnvService.getVar("TRACING_ENABLED", "boolean", false);
 	const workflowsPath = options.workflowsPath ? toWorkflowsPath(options.workflowsPath) : void 0;
 	const mergedInterceptors = mergeInterceptors(buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, workflowsPath), options.interceptors);
+	const { workflowTypes, service: serviceOverride, ...workerCreateOptions } = options;
 	try {
-		return await Worker.create({
+		const worker = await Worker.create({
 			namespace,
 			taskQueue,
 			connection: await NativeConnection.connect({ address }),
 			dataConverter: encryptionEnabled ? await getDataConverter(encryptionKeyId, envService, encryptionKeyRefreshInterval) : void 0,
-			...options,
+			...workerCreateOptions,
 			workflowsPath,
 			sinks: tracingEnabled ? { exporter: makeWorkflowExporter(traceExporter, resource) } : void 0,
 			interceptors: mergedInterceptors
 		});
+		if (taskQueue) try {
+			registerWorkerInfo({
+				namespace,
+				taskQueue,
+				service: serviceOverride,
+				workflowTypes: workflowTypes ?? (workflowsPath ? await deriveWorkflowTypes(workflowsPath, logger) : void 0)
+			});
+		} catch (err) {
+			logger?.warn("Failed to record diia_temporal_worker_info metric", { err });
+		}
+		return worker;
 	} catch (err) {
 		logger?.error("Failed to create Temporal worker", { err });
 		throw new Error("Failed to create Temporal worker", { cause: err });

package/dist/worker.d.ts

@@ -3,5 +3,6 @@ import { ActivityClass, App, WorkerBootstrapOptions } from "./interfaces/service
 import { WorkerHealthDetails, WorkerHealthService } from "./services/workerHealth.js";
 import { buildWorkerIdentity } from "./services/worker/identity.js";
 import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath } from "./services/worker.js";
+import { RegisterWorkerInfoParams, WORKER_INFO_METRIC, WorkerInfoLabels, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService } from "./services/worker/info.js";
 import { NativeConnection, Runtime, State, Worker, WorkerInterceptors, WorkerOptions, WorkerStatus, bundleWorkflowCode } from "@temporalio/worker";
-export { ActivityClass, App, NativeConnection, Runtime, type State, Worker, WorkerBootstrapOptions, WorkerHealthDetails, WorkerHealthService, type WorkerInterceptors, type WorkerOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath, workflowInterceptors };
+export { ActivityClass, App, NativeConnection, RegisterWorkerInfoParams, Runtime, type State, WORKER_INFO_METRIC, Worker, WorkerBootstrapOptions, WorkerHealthDetails, WorkerHealthService, WorkerInfoLabels, type WorkerInterceptors, type WorkerOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initTemporalWorker, initWorker, instantiateActivities, registerWorkerInfo, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/dist/worker.js

@@ -1,6 +1,7 @@
 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, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath } from "./services/worker.js";
 import { NativeConnection, Runtime, Worker, bundleWorkflowCode } from "@temporalio/worker";
-export { NativeConnection, Runtime, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath, workflowInterceptors };
+export { NativeConnection, Runtime, WORKER_INFO_METRIC, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initTemporalWorker, initWorker, instantiateActivities, registerWorkerInfo, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/workflow",
-    "version": "2.7.0",
+    "version": "2.8.0",
     "description": "Workflow",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -100,15 +100,15 @@
     },
     "devDependencies": {
         "@diia-inhouse/configs": "7.0.1",
-        "@diia-inhouse/diia-logger": "4.3.13",
-        "@diia-inhouse/diia-metrics": "7.1.23",
-        "@diia-inhouse/diia-queue": "14.0.21",
-        "@diia-inhouse/env": "3.3.12",
-        "@diia-inhouse/healthcheck": "2.1.25",
+        "@diia-inhouse/diia-logger": "4.3.18",
+        "@diia-inhouse/diia-metrics": "7.1.26",
+        "@diia-inhouse/diia-queue": "14.0.23",
+        "@diia-inhouse/env": "3.3.17",
+        "@diia-inhouse/healthcheck": "2.1.30",
         "@diia-inhouse/oxc-config": "1.11.0",
-        "@diia-inhouse/test": "8.2.9",
-        "@diia-inhouse/types": "13.2.2",
-        "@diia-inhouse/utils": "6.0.21",
+        "@diia-inhouse/test": "8.2.10",
+        "@diia-inhouse/types": "13.3.0",
+        "@diia-inhouse/utils": "6.0.25",
         "@types/lodash": "4.17.24",
         "@types/node": "25.6.2",
         "@types/yargs": "17.0.35",