feat(core): Introduce worker metrics (#10850)

packages/cli/src/scaling/__tests__/worker-server.test.ts

@@ -7,6 +7,7 @@ import * as http from 'node:http';
 
 import { PortTakenError } from '@/errors/port-taken.error';
 import type { ExternalHooks } from '@/external-hooks';
+import type { PrometheusMetricsService } from '@/metrics/prometheus-metrics.service';
 import { bodyParser, rawBodyReader } from '@/middlewares';
 
 import { WorkerServer } from '../worker-server';
@@ -28,6 +29,7 @@ describe('WorkerServer', () => {
 
 	const externalHooks = mock<ExternalHooks>();
 	const instanceSettings = mock<InstanceSettings>({ instanceType: 'worker' });
+	const prometheusMetricsService = mock<PrometheusMetricsService>();
 
 	beforeEach(() => {
 		globalConfig = mock<GlobalConfig>({
@@ -52,6 +54,7 @@ describe('WorkerServer', () => {
 						mock(),
 						externalHooks,
 						mock<InstanceSettings>({ instanceType: 'webhook' }),
+						prometheusMetricsService,
 					),
 			).toThrowError(AssertionError);
 		});
@@ -68,55 +71,21 @@ describe('WorkerServer', () => {
 
 			expect(
 				() =>
-					new WorkerServer(globalConfig, mock(), mock(), mock(), externalHooks, instanceSettings),
+					new WorkerServer(
+						globalConfig,
+						mock(),
+						mock(),
+						mock(),
+						externalHooks,
+						instanceSettings,
+						prometheusMetricsService,
+					),
 			).toThrowError(PortTakenError);
 		});
-
-		it('should set up `/healthz` if health check is enabled', async () => {
-			jest.spyOn(http, 'createServer').mockReturnValue(mock<http.Server>());
-
-			new WorkerServer(globalConfig, mock(), mock(), mock(), externalHooks, instanceSettings);
-
-			expect(app.get).toHaveBeenCalledWith('/healthz', expect.any(Function));
-		});
-
-		it('should not set up `/healthz` if health check is disabled', async () => {
-			globalConfig.queue.health.active = false;
-
-			jest.spyOn(http, 'createServer').mockReturnValue(mock<http.Server>());
-
-			new WorkerServer(globalConfig, mock(), mock(), mock(), externalHooks, instanceSettings);
-
-			expect(app.get).not.toHaveBeenCalled();
-		});
-
-		it('should set up `/:endpoint` if overwrites endpoint is set', async () => {
-			jest.spyOn(http, 'createServer').mockReturnValue(mock<http.Server>());
-
-			const CREDENTIALS_OVERWRITE_ENDPOINT = 'credentials/overwrites';
-			globalConfig.credentials.overwrite.endpoint = CREDENTIALS_OVERWRITE_ENDPOINT;
-
-			new WorkerServer(globalConfig, mock(), mock(), mock(), externalHooks, instanceSettings);
-
-			expect(app.post).toHaveBeenCalledWith(
-				`/${CREDENTIALS_OVERWRITE_ENDPOINT}`,
-				rawBodyReader,
-				bodyParser,
-				expect.any(Function),
-			);
-		});
-
-		it('should not set up `/:endpoint` if overwrites endpoint is not set', async () => {
-			jest.spyOn(http, 'createServer').mockReturnValue(mock<http.Server>());
-
-			new WorkerServer(globalConfig, mock(), mock(), mock(), externalHooks, instanceSettings);
-
-			expect(app.post).not.toHaveBeenCalled();
-		});
 	});
 
 	describe('init', () => {
-		it('should call `worker.ready` external hook', async () => {
+		it('should mount all endpoints when all are enabled', async () => {
 			const server = mock<http.Server>();
 			jest.spyOn(http, 'createServer').mockReturnValue(server);
 
@@ -132,8 +101,88 @@ describe('WorkerServer', () => {
 				mock(),
 				externalHooks,
 				instanceSettings,
+				prometheusMetricsService,
 			);
-			await workerServer.init();
+
+			const CREDENTIALS_OVERWRITE_ENDPOINT = 'credentials/overwrites';
+			globalConfig.credentials.overwrite.endpoint = CREDENTIALS_OVERWRITE_ENDPOINT;
+
+			await workerServer.init({ health: true, overwrites: true, metrics: true });
+
+			expect(app.get).toHaveBeenCalledWith('/healthz', expect.any(Function));
+			expect(app.post).toHaveBeenCalledWith(
+				`/${CREDENTIALS_OVERWRITE_ENDPOINT}`,
+				rawBodyReader,
+				bodyParser,
+				expect.any(Function),
+			);
+			expect(prometheusMetricsService.init).toHaveBeenCalledWith(app);
+		});
+
+		it('should mount only health and overwrites endpoints if only those are enabled', async () => {
+			const server = mock<http.Server>();
+			jest.spyOn(http, 'createServer').mockReturnValue(server);
+
+			server.listen.mockImplementation((_port, callback: () => void) => {
+				callback();
+				return server;
+			});
+
+			const workerServer = new WorkerServer(
+				globalConfig,
+				mock(),
+				mock(),
+				mock(),
+				externalHooks,
+				instanceSettings,
+				prometheusMetricsService,
+			);
+
+			await workerServer.init({ health: true, overwrites: false, metrics: true });
+
+			expect(app.get).toHaveBeenCalledWith('/healthz', expect.any(Function));
+			expect(app.post).not.toHaveBeenCalled();
+			expect(prometheusMetricsService.init).toHaveBeenCalledWith(app);
+		});
+
+		it('should throw if no endpoints are enabled', async () => {
+			const server = mock<http.Server>();
+			jest.spyOn(http, 'createServer').mockReturnValue(server);
+
+			const workerServer = new WorkerServer(
+				globalConfig,
+				mock(),
+				mock(),
+				mock(),
+				externalHooks,
+				instanceSettings,
+				prometheusMetricsService,
+			);
+			await expect(
+				workerServer.init({ health: false, overwrites: false, metrics: false }),
+			).rejects.toThrowError(AssertionError);
+		});
+
+		it('should call `worker.ready` external hook', async () => {
+			const server = mock<http.Server>();
+			jest.spyOn(http, 'createServer').mockReturnValue(server);
+
+			const workerServer = new WorkerServer(
+				globalConfig,
+				mock(),
+				mock(),
+				mock(),
+				externalHooks,
+				instanceSettings,
+				prometheusMetricsService,
+			);
+
+			server.listen.mockImplementation((_port, callback: () => void) => {
+				callback();
+				return server;
+			});
+
+			await workerServer.init({ health: true, overwrites: true, metrics: true });
 
 			expect(externalHooks.run).toHaveBeenCalledWith('worker.ready');
 		});

packages/cli/src/scaling/worker-server.ts

@@ -1,4 +1,5 @@
 import { GlobalConfig } from '@n8n/config';
+import type { Application } from 'express';
 import express from 'express';
 import { InstanceSettings } from 'n8n-core';
 import { ensureError } from 'n8n-workflow';
@@ -16,10 +17,22 @@ import { ServiceUnavailableError } from '@/errors/response-errors/service-unavai
 import { ExternalHooks } from '@/external-hooks';
 import type { ICredentialsOverwrite } from '@/interfaces';
 import { Logger } from '@/logger';
+import { PrometheusMetricsService } from '@/metrics/prometheus-metrics.service';
 import { rawBodyReader, bodyParser } from '@/middlewares';
 import * as ResponseHelper from '@/response-helper';
 import { ScalingService } from '@/scaling/scaling.service';
 
+export type WorkerServerEndpointsConfig = {
+	/** Whether the `/healthz` endpoint is enabled. */
+	health: boolean;
+
+	/** Whether the [credentials overwrites endpoint](https://docs.n8n.io/embed/configuration/#credential-overwrites) is enabled. */
+	overwrites: boolean;
+
+	/** Whether the `/metrics` endpoint is enabled. */
+	metrics: boolean;
+};
+
 /**
  * Responsible for handling HTTP requests sent to a worker.
  */
@@ -29,9 +42,10 @@ export class WorkerServer {
 
 	private readonly server: Server;
 
-	/**
-	 * @doc https://docs.n8n.io/embed/configuration/#credential-overwrites
-	 */
+	private readonly app: Application;
+
+	private endpointsConfig: WorkerServerEndpointsConfig;
+
 	private overwritesLoaded = false;
 
 	constructor(
@@ -41,35 +55,30 @@ export class WorkerServer {
 		private readonly credentialsOverwrites: CredentialsOverwrites,
 		private readonly externalHooks: ExternalHooks,
 		private readonly instanceSettings: InstanceSettings,
+		private readonly prometheusMetricsService: PrometheusMetricsService,
 	) {
 		assert(this.instanceSettings.instanceType === 'worker');
 
-		const app = express();
+		this.app = express();
 
-		app.disable('x-powered-by');
+		this.app.disable('x-powered-by');
 
-		this.server = http.createServer(app);
+		this.server = http.createServer(this.app);
 
 		this.port = this.globalConfig.queue.health.port;
 
-		const overwritesEndpoint = this.globalConfig.credentials.overwrite.endpoint;
-
 		this.server.on('error', (error: NodeJS.ErrnoException) => {
 			if (error.code === 'EADDRINUSE') throw new PortTakenError(this.port);
 		});
-
-		if (this.globalConfig.queue.health.active) {
-			app.get('/healthz', async (req, res) => await this.healthcheck(req, res));
-		}
-
-		if (overwritesEndpoint !== '') {
-			app.post(`/${overwritesEndpoint}`, rawBodyReader, bodyParser, (req, res) =>
-				this.handleOverwrites(req, res),
-			);
-		}
 	}
 
-	async init() {
+	async init(endpointsConfig: WorkerServerEndpointsConfig) {
+		assert(Object.values(endpointsConfig).some((e) => e));
+
+		this.endpointsConfig = endpointsConfig;
+
+		await this.mountEndpoints();
+
 		await new Promise<void>((resolve) => this.server.listen(this.port, resolve));
 
 		await this.externalHooks.run('worker.ready');
@@ -77,6 +86,24 @@ export class WorkerServer {
 		this.logger.info(`\nn8n worker server listening on port ${this.port}`);
 	}
 
+	private async mountEndpoints() {
+		if (this.endpointsConfig.health) {
+			this.app.get('/healthz', async (req, res) => await this.healthcheck(req, res));
+		}
+
+		if (this.endpointsConfig.overwrites) {
+			const { endpoint } = this.globalConfig.credentials.overwrite;
+
+			this.app.post(`/${endpoint}`, rawBodyReader, bodyParser, (req, res) =>
+				this.handleOverwrites(req, res),
+			);
+		}
+
+		if (this.endpointsConfig.metrics) {
+			await this.prometheusMetricsService.init(this.app);
+		}
+	}
+
 	private async healthcheck(_req: express.Request, res: express.Response) {
 		this.logger.debug('[WorkerServer] Health check started');