Update test framework: fix run_tests.py to support all test files, add auto-import-check for test files

node_modules/prom-client/lib/metrics/eventLoopLag.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const Gauge = require('../gauge');
+
+// Check if perf_hooks module is available
+let perf_hooks;
+try {
+	perf_hooks = require('perf_hooks');
+} catch {
+	// node version is too old
+}
+
+// Reported always.
+const NODEJS_EVENTLOOP_LAG = 'nodejs_eventloop_lag_seconds';
+
+// Reported only when perf_hooks is available.
+const NODEJS_EVENTLOOP_LAG_MIN = 'nodejs_eventloop_lag_min_seconds';
+const NODEJS_EVENTLOOP_LAG_MAX = 'nodejs_eventloop_lag_max_seconds';
+const NODEJS_EVENTLOOP_LAG_MEAN = 'nodejs_eventloop_lag_mean_seconds';
+const NODEJS_EVENTLOOP_LAG_STDDEV = 'nodejs_eventloop_lag_stddev_seconds';
+const NODEJS_EVENTLOOP_LAG_P50 = 'nodejs_eventloop_lag_p50_seconds';
+const NODEJS_EVENTLOOP_LAG_P90 = 'nodejs_eventloop_lag_p90_seconds';
+const NODEJS_EVENTLOOP_LAG_P99 = 'nodejs_eventloop_lag_p99_seconds';
+
+function reportEventloopLag(start, gauge, labels) {
+	const delta = process.hrtime(start);
+	const nanosec = delta[0] * 1e9 + delta[1];
+	const seconds = nanosec / 1e9;
+
+	gauge.set(labels, seconds);
+}
+
+module.exports = (registry, config = {}) => {
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+	const registers = registry ? [registry] : undefined;
+
+	let collect = () => {
+		const start = process.hrtime();
+		setImmediate(reportEventloopLag, start, lag, labels);
+	};
+
+	if (perf_hooks && perf_hooks.monitorEventLoopDelay) {
+		try {
+			const histogram = perf_hooks.monitorEventLoopDelay({
+				resolution: config.eventLoopMonitoringPrecision,
+			});
+			histogram.enable();
+
+			collect = () => {
+				const start = process.hrtime();
+				setImmediate(reportEventloopLag, start, lag, labels);
+
+				lagMin.set(labels, histogram.min / 1e9);
+				lagMax.set(labels, histogram.max / 1e9);
+				lagMean.set(labels, histogram.mean / 1e9);
+				lagStddev.set(labels, histogram.stddev / 1e9);
+				lagP50.set(labels, histogram.percentile(50) / 1e9);
+				lagP90.set(labels, histogram.percentile(90) / 1e9);
+				lagP99.set(labels, histogram.percentile(99) / 1e9);
+
+				histogram.reset();
+			};
+		} catch (e) {
+			if (e.code === 'ERR_NOT_IMPLEMENTED') {
+				return; // Bun
+			}
+
+			throw e;
+		}
+	}
+
+	const lag = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG,
+		help: 'Lag of event loop in seconds.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+		// Use this one metric's `collect` to set all metrics' values.
+		collect,
+	});
+	const lagMin = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_MIN,
+		help: 'The minimum recorded event loop delay.',
+		registers,
+		labelNames,
+		aggregator: 'min',
+	});
+	const lagMax = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_MAX,
+		help: 'The maximum recorded event loop delay.',
+		registers,
+		labelNames,
+		aggregator: 'max',
+	});
+	const lagMean = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_MEAN,
+		help: 'The mean of the recorded event loop delays.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+	});
+	const lagStddev = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_STDDEV,
+		help: 'The standard deviation of the recorded event loop delays.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+	});
+	const lagP50 = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_P50,
+		help: 'The 50th percentile of the recorded event loop delays.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+	});
+	const lagP90 = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_P90,
+		help: 'The 90th percentile of the recorded event loop delays.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+	});
+	const lagP99 = new Gauge({
+		name: namePrefix + NODEJS_EVENTLOOP_LAG_P99,
+		help: 'The 99th percentile of the recorded event loop delays.',
+		registers,
+		labelNames,
+		aggregator: 'average',
+	});
+};
+
+module.exports.metricNames = [
+	NODEJS_EVENTLOOP_LAG,
+	NODEJS_EVENTLOOP_LAG_MIN,
+	NODEJS_EVENTLOOP_LAG_MAX,
+	NODEJS_EVENTLOOP_LAG_MEAN,
+	NODEJS_EVENTLOOP_LAG_STDDEV,
+	NODEJS_EVENTLOOP_LAG_P50,
+	NODEJS_EVENTLOOP_LAG_P90,
+	NODEJS_EVENTLOOP_LAG_P99,
+];

node_modules/prom-client/lib/metrics/gc.js

@@ -0,0 +1,58 @@
+'use strict';
+const Histogram = require('../histogram');
+
+let perf_hooks;
+
+try {
+	// eslint-disable-next-line
+	perf_hooks = require('perf_hooks');
+} catch {
+	// node version is too old
+}
+
+const NODEJS_GC_DURATION_SECONDS = 'nodejs_gc_duration_seconds';
+const DEFAULT_GC_DURATION_BUCKETS = [0.001, 0.01, 0.1, 1, 2, 5];
+
+const kinds = [];
+
+if (perf_hooks && perf_hooks.constants) {
+	kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR] = 'major';
+	kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR] = 'minor';
+	kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL] = 'incremental';
+	kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB] = 'weakcb';
+}
+
+module.exports = (registry, config = {}) => {
+	if (!perf_hooks) {
+		return;
+	}
+
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+	const buckets = config.gcDurationBuckets
+		? config.gcDurationBuckets
+		: DEFAULT_GC_DURATION_BUCKETS;
+	const gcHistogram = new Histogram({
+		name: namePrefix + NODEJS_GC_DURATION_SECONDS,
+		help: 'Garbage collection duration by kind, one of major, minor, incremental or weakcb.',
+		labelNames: ['kind', ...labelNames],
+		enableExemplars: false,
+		buckets,
+		registers: registry ? [registry] : undefined,
+	});
+
+	const obs = new perf_hooks.PerformanceObserver(list => {
+		const entry = list.getEntries()[0];
+		// Node < 16 uses entry.kind
+		// Node >= 16 uses entry.detail.kind
+		// See: https://nodejs.org/docs/latest-v16.x/api/deprecations.html#deprecations_dep0152_extension_performanceentry_properties
+		const kind = entry.detail ? kinds[entry.detail.kind] : kinds[entry.kind];
+		// Convert duration from milliseconds to seconds
+		gcHistogram.observe(Object.assign({ kind }, labels), entry.duration / 1000);
+	});
+
+	obs.observe({ entryTypes: ['gc'] });
+};
+
+module.exports.metricNames = [NODEJS_GC_DURATION_SECONDS];

node_modules/prom-client/lib/metrics/heapSizeAndUsed.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const safeMemoryUsage = require('./helpers/safeMemoryUsage');
+
+const NODEJS_HEAP_SIZE_TOTAL = 'nodejs_heap_size_total_bytes';
+const NODEJS_HEAP_SIZE_USED = 'nodejs_heap_size_used_bytes';
+const NODEJS_EXTERNAL_MEMORY = 'nodejs_external_memory_bytes';
+
+module.exports = (registry, config = {}) => {
+	if (typeof process.memoryUsage !== 'function') {
+		return;
+	}
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	const registers = registry ? [registry] : undefined;
+	const namePrefix = config.prefix ? config.prefix : '';
+	const collect = () => {
+		const memUsage = safeMemoryUsage();
+		if (memUsage) {
+			heapSizeTotal.set(labels, memUsage.heapTotal);
+			heapSizeUsed.set(labels, memUsage.heapUsed);
+			if (memUsage.external !== undefined) {
+				externalMemUsed.set(labels, memUsage.external);
+			}
+		}
+	};
+
+	const heapSizeTotal = new Gauge({
+		name: namePrefix + NODEJS_HEAP_SIZE_TOTAL,
+		help: 'Process heap size from Node.js in bytes.',
+		registers,
+		labelNames,
+		// Use this one metric's `collect` to set all metrics' values.
+		collect,
+	});
+	const heapSizeUsed = new Gauge({
+		name: namePrefix + NODEJS_HEAP_SIZE_USED,
+		help: 'Process heap size used from Node.js in bytes.',
+		registers,
+		labelNames,
+	});
+	const externalMemUsed = new Gauge({
+		name: namePrefix + NODEJS_EXTERNAL_MEMORY,
+		help: 'Node.js external memory size in bytes.',
+		registers,
+		labelNames,
+	});
+};
+
+module.exports.metricNames = [
+	NODEJS_HEAP_SIZE_TOTAL,
+	NODEJS_HEAP_SIZE_USED,
+	NODEJS_EXTERNAL_MEMORY,
+];

node_modules/prom-client/lib/metrics/heapSpacesSizeAndUsed.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const v8 = require('v8');
+
+const METRICS = ['total', 'used', 'available'];
+const NODEJS_HEAP_SIZE = {};
+
+METRICS.forEach(metricType => {
+	NODEJS_HEAP_SIZE[metricType] = `nodejs_heap_space_size_${metricType}_bytes`;
+});
+
+module.exports = (registry, config = {}) => {
+	try {
+		v8.getHeapSpaceStatistics();
+	} catch (e) {
+		if (e.code === 'ERR_NOT_IMPLEMENTED') {
+			return; // Bun
+		}
+		throw e;
+	}
+	const registers = registry ? [registry] : undefined;
+	const namePrefix = config.prefix ? config.prefix : '';
+
+	const labels = config.labels ? config.labels : {};
+	const labelNames = ['space', ...Object.keys(labels)];
+
+	const gauges = {};
+
+	METRICS.forEach(metricType => {
+		gauges[metricType] = new Gauge({
+			name: namePrefix + NODEJS_HEAP_SIZE[metricType],
+			help: `Process heap space size ${metricType} from Node.js in bytes.`,
+			labelNames,
+			registers,
+		});
+	});
+
+	// Use this one metric's `collect` to set all metrics' values.
+	gauges.total.collect = () => {
+		for (const space of v8.getHeapSpaceStatistics()) {
+			const spaceName = space.space_name.substr(
+				0,
+				space.space_name.indexOf('_space'),
+			);
+
+			gauges.total.set({ space: spaceName, ...labels }, space.space_size);
+			gauges.used.set({ space: spaceName, ...labels }, space.space_used_size);
+			gauges.available.set(
+				{ space: spaceName, ...labels },
+				space.space_available_size,
+			);
+		}
+	};
+};
+
+module.exports.metricNames = Object.values(NODEJS_HEAP_SIZE);

node_modules/prom-client/lib/metrics/helpers/processMetricsHelpers.js

@@ -0,0 +1,32 @@
+'use strict';
+
+function aggregateByObjectName(list) {
+	const data = {};
+
+	for (let i = 0; i < list.length; i++) {
+		const listElement = list[i];
+
+		if (!listElement || typeof listElement.constructor === 'undefined') {
+			continue;
+		}
+
+		if (Object.hasOwnProperty.call(data, listElement.constructor.name)) {
+			data[listElement.constructor.name] += 1;
+		} else {
+			data[listElement.constructor.name] = 1;
+		}
+	}
+	return data;
+}
+
+function updateMetrics(gauge, data, labels) {
+	gauge.reset();
+	for (const key in data) {
+		gauge.set(Object.assign({ type: key }, labels || {}), data[key]);
+	}
+}
+
+module.exports = {
+	aggregateByObjectName,
+	updateMetrics,
+};

node_modules/prom-client/lib/metrics/helpers/safeMemoryUsage.js

@@ -0,0 +1,12 @@
+'use strict';
+
+// process.memoryUsage() can throw on some platforms, see #67
+function safeMemoryUsage() {
+	try {
+		return process.memoryUsage();
+	} catch {
+		return;
+	}
+}
+
+module.exports = safeMemoryUsage;

node_modules/prom-client/lib/metrics/osMemoryHeap.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const linuxVariant = require('./osMemoryHeapLinux');
+const safeMemoryUsage = require('./helpers/safeMemoryUsage');
+
+const PROCESS_RESIDENT_MEMORY = 'process_resident_memory_bytes';
+
+function notLinuxVariant(registry, config = {}) {
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + PROCESS_RESIDENT_MEMORY,
+		help: 'Resident memory size in bytes.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		collect() {
+			const memUsage = safeMemoryUsage();
+
+			// I don't think the other things returned from `process.memoryUsage()` is relevant to a standard export
+			if (memUsage) {
+				this.set(labels, memUsage.rss);
+			}
+		},
+	});
+}
+
+module.exports = (registry, config) =>
+	process.platform === 'linux'
+		? linuxVariant(registry, config)
+		: notLinuxVariant(registry, config);
+
+module.exports.metricNames =
+	process.platform === 'linux'
+		? linuxVariant.metricNames
+		: [PROCESS_RESIDENT_MEMORY];

node_modules/prom-client/lib/metrics/osMemoryHeapLinux.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const fs = require('fs');
+
+const values = ['VmSize', 'VmRSS', 'VmData'];
+
+const PROCESS_RESIDENT_MEMORY = 'process_resident_memory_bytes';
+const PROCESS_VIRTUAL_MEMORY = 'process_virtual_memory_bytes';
+const PROCESS_HEAP = 'process_heap_bytes';
+
+function structureOutput(input) {
+	return input.split('\n').reduce((acc, string) => {
+		if (!values.some(value => string.startsWith(value))) {
+			return acc;
+		}
+
+		const split = string.split(':');
+
+		// Get the value
+		let value = split[1].trim();
+		// Remove trailing ` kb`
+		value = value.substr(0, value.length - 3);
+		// Make it into a number in bytes bytes
+		value = Number(value) * 1024;
+
+		acc[split[0]] = value;
+
+		return acc;
+	}, {});
+}
+
+module.exports = (registry, config = {}) => {
+	const registers = registry ? [registry] : undefined;
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	const residentMemGauge = new Gauge({
+		name: namePrefix + PROCESS_RESIDENT_MEMORY,
+		help: 'Resident memory size in bytes.',
+		registers,
+		labelNames,
+		// Use this one metric's `collect` to set all metrics' values.
+		collect() {
+			try {
+				// Sync I/O is often problematic, but /proc isn't really I/O, it
+				// a virtual filesystem that maps directly to in-kernel data
+				// structures and never blocks.
+				//
+				// Node.js/libuv do this already for process.memoryUsage(), see:
+				// - https://github.com/libuv/libuv/blob/a629688008694ed8022269e66826d4d6ec688b83/src/unix/linux-core.c#L506-L523
+				const stat = fs.readFileSync('/proc/self/status', 'utf8');
+				const structuredOutput = structureOutput(stat);
+
+				residentMemGauge.set(labels, structuredOutput.VmRSS);
+				virtualMemGauge.set(labels, structuredOutput.VmSize);
+				heapSizeMemGauge.set(labels, structuredOutput.VmData);
+			} catch {
+				// noop
+			}
+		},
+	});
+	const virtualMemGauge = new Gauge({
+		name: namePrefix + PROCESS_VIRTUAL_MEMORY,
+		help: 'Virtual memory size in bytes.',
+		registers,
+		labelNames,
+	});
+	const heapSizeMemGauge = new Gauge({
+		name: namePrefix + PROCESS_HEAP,
+		help: 'Process heap size in bytes.',
+		registers,
+		labelNames,
+	});
+};
+
+module.exports.metricNames = [
+	PROCESS_RESIDENT_MEMORY,
+	PROCESS_VIRTUAL_MEMORY,
+	PROCESS_HEAP,
+];

node_modules/prom-client/lib/metrics/processCpuTotal.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const OtelApi = require('@opentelemetry/api');
+const Counter = require('../counter');
+
+const PROCESS_CPU_USER_SECONDS = 'process_cpu_user_seconds_total';
+const PROCESS_CPU_SYSTEM_SECONDS = 'process_cpu_system_seconds_total';
+const PROCESS_CPU_SECONDS = 'process_cpu_seconds_total';
+
+module.exports = (registry, config = {}) => {
+	const registers = registry ? [registry] : undefined;
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const exemplars = config.enableExemplars ? config.enableExemplars : false;
+	const labelNames = Object.keys(labels);
+
+	let lastCpuUsage = process.cpuUsage();
+
+	const cpuUserUsageCounter = new Counter({
+		name: namePrefix + PROCESS_CPU_USER_SECONDS,
+		help: 'Total user CPU time spent in seconds.',
+		enableExemplars: exemplars,
+		registers,
+		labelNames,
+		// Use this one metric's `collect` to set all metrics' values.
+		collect() {
+			const cpuUsage = process.cpuUsage();
+
+			const userUsageMicros = cpuUsage.user - lastCpuUsage.user;
+			const systemUsageMicros = cpuUsage.system - lastCpuUsage.system;
+
+			lastCpuUsage = cpuUsage;
+
+			if (this.enableExemplars) {
+				let exemplarLabels = {};
+				const currentSpan = OtelApi.trace.getSpan(OtelApi.context.active());
+				if (currentSpan) {
+					exemplarLabels = {
+						traceId: currentSpan.spanContext().traceId,
+						spanId: currentSpan.spanContext().spanId,
+					};
+				}
+				cpuUserUsageCounter.inc({
+					labels,
+					value: userUsageMicros / 1e6,
+					exemplarLabels,
+				});
+				cpuSystemUsageCounter.inc({
+					labels,
+					value: systemUsageMicros / 1e6,
+					exemplarLabels,
+				});
+				cpuUsageCounter.inc({
+					labels,
+					value: (userUsageMicros + systemUsageMicros) / 1e6,
+					exemplarLabels,
+				});
+			} else {
+				cpuUserUsageCounter.inc(labels, userUsageMicros / 1e6);
+				cpuSystemUsageCounter.inc(labels, systemUsageMicros / 1e6);
+				cpuUsageCounter.inc(
+					labels,
+					(userUsageMicros + systemUsageMicros) / 1e6,
+				);
+			}
+		},
+	});
+	const cpuSystemUsageCounter = new Counter({
+		name: namePrefix + PROCESS_CPU_SYSTEM_SECONDS,
+		help: 'Total system CPU time spent in seconds.',
+		enableExemplars: exemplars,
+		registers,
+		labelNames,
+	});
+	const cpuUsageCounter = new Counter({
+		name: namePrefix + PROCESS_CPU_SECONDS,
+		help: 'Total user and system CPU time spent in seconds.',
+		enableExemplars: exemplars,
+		registers,
+		labelNames,
+	});
+};
+
+module.exports.metricNames = [
+	PROCESS_CPU_USER_SECONDS,
+	PROCESS_CPU_SYSTEM_SECONDS,
+	PROCESS_CPU_SECONDS,
+];

node_modules/prom-client/lib/metrics/processHandles.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { aggregateByObjectName } = require('./helpers/processMetricsHelpers');
+const { updateMetrics } = require('./helpers/processMetricsHelpers');
+const Gauge = require('../gauge');
+
+const NODEJS_ACTIVE_HANDLES = 'nodejs_active_handles';
+const NODEJS_ACTIVE_HANDLES_TOTAL = 'nodejs_active_handles_total';
+
+module.exports = (registry, config = {}) => {
+	// Don't do anything if the function is removed in later nodes (exists in node@6-12...)
+	if (typeof process._getActiveHandles !== 'function') {
+		return;
+	}
+
+	const registers = registry ? [registry] : undefined;
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_HANDLES,
+		help: 'Number of active libuv handles grouped by handle type. Every handle type is C++ class name.',
+		labelNames: ['type', ...labelNames],
+		registers,
+		collect() {
+			const handles = process._getActiveHandles();
+			updateMetrics(this, aggregateByObjectName(handles), labels);
+		},
+	});
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_HANDLES_TOTAL,
+		help: 'Total number of active handles.',
+		registers,
+		labelNames,
+		collect() {
+			const handles = process._getActiveHandles();
+			this.set(labels, handles.length);
+		},
+	});
+};
+
+module.exports.metricNames = [
+	NODEJS_ACTIVE_HANDLES,
+	NODEJS_ACTIVE_HANDLES_TOTAL,
+];

node_modules/prom-client/lib/metrics/processMaxFileDescriptors.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const fs = require('fs');
+
+const PROCESS_MAX_FDS = 'process_max_fds';
+
+let maxFds;
+
+module.exports = (registry, config = {}) => {
+	if (maxFds === undefined) {
+		// This will fail if a linux-like procfs is not available.
+		try {
+			const limits = fs.readFileSync('/proc/self/limits', 'utf8');
+			const lines = limits.split('\n');
+			for (const line of lines) {
+				if (line.startsWith('Max open files')) {
+					const parts = line.split(/  +/);
+					maxFds = Number(parts[1]);
+					break;
+				}
+			}
+		} catch {
+			return;
+		}
+	}
+
+	if (maxFds === undefined) return;
+
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + PROCESS_MAX_FDS,
+		help: 'Maximum number of open file descriptors.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		collect() {
+			if (maxFds !== undefined) this.set(labels, maxFds);
+		},
+	});
+};
+
+module.exports.metricNames = [PROCESS_MAX_FDS];

node_modules/prom-client/lib/metrics/processOpenFileDescriptors.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const fs = require('fs');
+const process = require('process');
+
+const PROCESS_OPEN_FDS = 'process_open_fds';
+
+module.exports = (registry, config = {}) => {
+	if (process.platform !== 'linux') {
+		return;
+	}
+
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + PROCESS_OPEN_FDS,
+		help: 'Number of open file descriptors.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		collect() {
+			try {
+				const fds = fs.readdirSync('/proc/self/fd');
+				// Minus 1 to not count the fd that was used by readdirSync(),
+				// it's now closed.
+				this.set(labels, fds.length - 1);
+			} catch {
+				// noop
+			}
+		},
+	});
+};
+
+module.exports.metricNames = [PROCESS_OPEN_FDS];

node_modules/prom-client/lib/metrics/processRequests.js

@@ -0,0 +1,45 @@
+'use strict';
+const Gauge = require('../gauge');
+const { aggregateByObjectName } = require('./helpers/processMetricsHelpers');
+const { updateMetrics } = require('./helpers/processMetricsHelpers');
+
+const NODEJS_ACTIVE_REQUESTS = 'nodejs_active_requests';
+const NODEJS_ACTIVE_REQUESTS_TOTAL = 'nodejs_active_requests_total';
+
+module.exports = (registry, config = {}) => {
+	// Don't do anything if the function is removed in later nodes (exists in node@6)
+	if (typeof process._getActiveRequests !== 'function') {
+		return;
+	}
+
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_REQUESTS,
+		help: 'Number of active libuv requests grouped by request type. Every request type is C++ class name.',
+		labelNames: ['type', ...labelNames],
+		registers: registry ? [registry] : undefined,
+		collect() {
+			const requests = process._getActiveRequests();
+			updateMetrics(this, aggregateByObjectName(requests), labels);
+		},
+	});
+
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_REQUESTS_TOTAL,
+		help: 'Total number of active requests.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		collect() {
+			const requests = process._getActiveRequests();
+			this.set(labels, requests.length);
+		},
+	});
+};
+
+module.exports.metricNames = [
+	NODEJS_ACTIVE_REQUESTS,
+	NODEJS_ACTIVE_REQUESTS_TOTAL,
+];

node_modules/prom-client/lib/metrics/processResources.js

@@ -0,0 +1,57 @@
+'use strict';
+const Gauge = require('../gauge');
+const { updateMetrics } = require('./helpers/processMetricsHelpers');
+
+const NODEJS_ACTIVE_RESOURCES = 'nodejs_active_resources';
+const NODEJS_ACTIVE_RESOURCES_TOTAL = 'nodejs_active_resources_total';
+
+module.exports = (registry, config = {}) => {
+	// Don't do anything if the function does not exist in previous nodes (exists in node@17.3.0)
+	if (typeof process.getActiveResourcesInfo !== 'function') {
+		return;
+	}
+
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_RESOURCES,
+		help: 'Number of active resources that are currently keeping the event loop alive, grouped by async resource type.',
+		labelNames: ['type', ...labelNames],
+		registers: registry ? [registry] : undefined,
+		collect() {
+			const resources = process.getActiveResourcesInfo();
+
+			const data = {};
+
+			for (let i = 0; i < resources.length; i++) {
+				const resource = resources[i];
+
+				if (Object.hasOwn(data, resource)) {
+					data[resource] += 1;
+				} else {
+					data[resource] = 1;
+				}
+			}
+
+			updateMetrics(this, data, labels);
+		},
+	});
+
+	new Gauge({
+		name: namePrefix + NODEJS_ACTIVE_RESOURCES_TOTAL,
+		help: 'Total number of active resources.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		collect() {
+			const resources = process.getActiveResourcesInfo();
+			this.set(labels, resources.length);
+		},
+	});
+};
+
+module.exports.metricNames = [
+	NODEJS_ACTIVE_RESOURCES,
+	NODEJS_ACTIVE_RESOURCES_TOTAL,
+];

node_modules/prom-client/lib/metrics/processStartTime.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const startInSeconds = Math.round(Date.now() / 1000 - process.uptime());
+
+const PROCESS_START_TIME = 'process_start_time_seconds';
+
+module.exports = (registry, config = {}) => {
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + PROCESS_START_TIME,
+		help: 'Start time of the process since unix epoch in seconds.',
+		registers: registry ? [registry] : undefined,
+		labelNames,
+		aggregator: 'omit',
+		collect() {
+			this.set(labels, startInSeconds);
+		},
+	});
+};
+
+module.exports.metricNames = [PROCESS_START_TIME];

node_modules/prom-client/lib/metrics/version.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Gauge = require('../gauge');
+const version = process.version;
+const versionSegments = version.slice(1).split('.').map(Number);
+
+const NODE_VERSION_INFO = 'nodejs_version_info';
+
+module.exports = (registry, config = {}) => {
+	const namePrefix = config.prefix ? config.prefix : '';
+	const labels = config.labels ? config.labels : {};
+	const labelNames = Object.keys(labels);
+
+	new Gauge({
+		name: namePrefix + NODE_VERSION_INFO,
+		help: 'Node.js version info.',
+		labelNames: ['version', 'major', 'minor', 'patch', ...labelNames],
+		registers: registry ? [registry] : undefined,
+		aggregator: 'first',
+		collect() {
+			// Needs to be in collect() so value is present even if reg is reset
+			this.labels(
+				version,
+				versionSegments[0],
+				versionSegments[1],
+				versionSegments[2],
+				...Object.values(labels),
+			).set(1);
+		},
+	});
+};
+
+module.exports.metricNames = [NODE_VERSION_INFO];