feat: support aggregating metrics across workers in a Node.js worker_…

…threads

example/workerThreads.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const express = require('express');
+const metricsServer = express();
+const AggregatorRegistry = require('../').AggregatorRegistry;
+/* eslint-disable node/no-unsupported-features/node-builtins */
+const { Worker, isMainThread } = require('worker_threads');
+
+const aggregatorRegistry = new AggregatorRegistry();
+
+if (isMainThread) {
+	metricsServer.get('/metrics', async (req, res) => {
+		try {
+			const metrics = await aggregatorRegistry.clusterMetrics();
+			res.set('Content-Type', aggregatorRegistry.contentType);
+			res.send(metrics);
+		} catch (ex) {
+			res.statusCode = 500;
+			res.send(ex.message);
+		}
+	});
+
+	metricsServer.listen(3000);
+
+	const worker = new Worker(__filename);
+
+	aggregatorRegistry.attachWorkers([worker]);
+} else {
+	const Histogram = require('../').Histogram;
+	const h = new Histogram({
+		name: 'test_histogram',
+		help: 'Example of a histogram',
+		labelNames: ['code'],
+	});
+
+	h.labels('200').observe(Math.random());
+}

lib/cluster.js

@@ -11,6 +11,20 @@
 const Registry = require('./registry');
 const { Grouper } = require('./util');
 const { aggregators } = require('./metricAggregators');
+
+let parentPort, MessageChannel, isMainThread, Worker;
+try {
+	/* eslint-disable node/no-unsupported-features/node-builtins */
+	const worker_threads = require('worker_threads');
+
+	parentPort = worker_threads.parentPort;
+	MessageChannel = worker_threads.MessageChannel;
+	isMainThread = worker_threads.isMainThread;
+	Worker = worker_threads.Worker;
+} catch {
+	// node version is too old
+}
+
 // We need to lazy-load the 'cluster' module as some application servers -
 // namely Passenger - crash when it is imported.
 let cluster = () => {
@@ -25,6 +39,7 @@ const GET_METRICS_RES = 'prom-client:getMetricsRes';
 let registries = [Registry.globalRegistry];
 let requestCtr = 0; // Concurrency control
 let listenersAdded = false;
+const workersQueue = [];
 const requests = new Map(); // Pending requests for workers' local metrics.
 
 class AggregatorRegistry extends Registry {
@@ -33,6 +48,14 @@ class AggregatorRegistry extends Registry {
 		addListeners();
 	}
 
+	attachWorkers(workers = []) {
+		for (const worker in workers) {
+			if (worker instanceof Worker) {
+				workersQueue.push(worker);
+			}
+		}
+	}
+
 	/**
 	 * Gets aggregated metrics for all workers. The optional callback and
 	 * returned Promise resolve with the same value; either may be used.
@@ -76,6 +99,9 @@ class AggregatorRegistry extends Registry {
 				}
 			}
 
+			getWorkerThreadsMetrics(message);
+			request.pending += workersQueue.length || 0;
+
 			if (request.pending === 0) {
 				// No workers were up
 				clearTimeout(request.errorTimeout);
@@ -145,6 +171,31 @@ class AggregatorRegistry extends Registry {
 	}
 }
 
+function handleWorkerResponse(worker, message) {
+	if (message.type === GET_METRICS_RES) {
+		const request = requests.get(message.requestId);
+		request.pending += message.workerRequests || 0;
+
+		if (message.error) {
+			request.done(new Error(message.error));
+			return;
+		}
+
+		message.metrics.forEach(registry => request.responses.push(registry));
+		request.pending--;
+
+		if (request.pending === 0) {
+			// finalize
+			requests.delete(message.requestId);
+			clearTimeout(request.errorTimeout);
+
+			const registry = AggregatorRegistry.aggregate(request.responses);
+			const promString = registry.metrics();
+			request.done(null, promString);
+		}
+	}
+}
+
 /**
  * Adds event listeners for cluster aggregation. Idempotent (safe to call more
  * than once).
@@ -155,42 +206,53 @@ function addListeners() {
 	listenersAdded = true;
 
 	if (cluster().isMaster) {
-		// Listen for worker responses to requests for local metrics
-		cluster().on('message', (worker, message) => {
-			if (message.type === GET_METRICS_RES) {
-				const request = requests.get(message.requestId);
-
-				if (message.error) {
-					request.done(new Error(message.error));
-					return;
-				}
+		// Listen for cluster responses to requests for local metrics
+		cluster().on('message', handleWorkerResponse);
+	}
+}
 
-				message.metrics.forEach(registry => request.responses.push(registry));
-				request.pending--;
+function getWorkerThreadsMetrics(message) {
+	workersQueue.forEach(worker => {
+		if (worker && worker instanceof Worker) {
+			const metricsChannel = new MessageChannel();
 
-				if (request.pending === 0) {
-					// finalize
-					requests.delete(message.requestId);
-					clearTimeout(request.errorTimeout);
+			worker.postMessage(
+				{
+					...message,
+					port: metricsChannel.port1,
+				},
+				[metricsChannel.port1],
+			);
 
-					const registry = AggregatorRegistry.aggregate(request.responses);
-					const promString = registry.metrics();
-					request.done(null, promString);
+			metricsChannel.port2.on('message', response => {
+				if (response.type === GET_METRICS_RES) {
+					if (cluster().isWorker) {
+						process.send(response);
+					}
+
+					if (cluster().isMaster) {
+						handleWorkerResponse(worker, response);
+					}
+
+					metricsChannel.port2.close();
 				}
-			}
-		});
-	}
+			});
+		}
+	});
 }
 
 // Respond to master's requests for worker's local metrics.
 process.on('message', message => {
 	if (cluster().isWorker && message.type === GET_METRICS_REQ) {
+		getWorkerThreadsMetrics(message);
+
 		Promise.all(registries.map(r => r.getMetricsAsJSON()))
 			.then(metrics => {
 				process.send({
 					type: GET_METRICS_RES,
 					requestId: message.requestId,
 					metrics,
+					workerRequests: workersQueue.length,
 				});
 			})
 			.catch(error => {
@@ -203,4 +265,27 @@ process.on('message', message => {
 	}
 });
 
+// Respond to master's request for worker_threads worker local metrics
+if (!isMainThread) {
+	parentPort.on('message', ({ type, requestId, port } = {}) => {
+		if (type === GET_METRICS_REQ) {
+			Promise.all(registries.map(r => r.getMetricsAsJSON()))
+				.then(metrics => {
+					port.postMessage({
+						type: GET_METRICS_RES,
+						requestId,
+						metrics,
+					});
+				})
+				.catch(error => {
+					port.postMessage({
+						type: GET_METRICS_RES,
+						requestId,
+						error: error.message,
+					});
+				});
+		}
+	});
+}
+
 module.exports = AggregatorRegistry;