Découpage en module

modules/game.js

@@ -0,0 +1,61 @@
+import utils from '../utils/utils.js';
+import metrics from './metrics.js';
+
+export default {
+	async requestStats(client, game) {
+		const stats = await utils.rconCommand(client, 'stats');
+		let statusLine = null;
+		if (stats) {
+			statusLine = stats.split(/\r?\n/);
+		} else {
+			return null;
+		}
+		if (game === 'csgo') {
+			statusLine = stats.split(/\r?\n/);
+			statusLine.pop();
+		}
+		statusLine.shift();
+		statusLine = statusLine[0].split(/\s+/);
+		return statusLine;
+	},
+	setStatsMetrics(response, game) {
+		if (game === 'csgo') {
+			metrics.status.set((Number(1)));
+			metrics.cpu.set((Number(response[0])));
+			metrics.netin.set((Number(response[1])));
+			metrics.netout.set((Number(response[2])));
+			metrics.uptime.set((Number(response[3])));
+			metrics.maps.set((Number(response[4])));
+			metrics.fps.set((Number(response[5])));
+			metrics.players.set((Number(response[6])));
+			metrics.svms.set((Number(response[7])));
+			metrics.varms.set((Number(response[8])));
+			metrics.svMaxUpdateRate.set((Number(response[9])));
+		} else {
+			metrics.status.set((Number(1)));
+			metrics.cpu.set((Number(response[0])));
+			metrics.netin.set((Number(response[1])));
+			metrics.netout.set((Number(response[2])));
+			metrics.uptime.set((Number(response[3])));
+			metrics.maps.set((Number(response[4])));
+			metrics.fps.set((Number(response[5])));
+			metrics.players.set((Number(response[6])));
+		}
+	},
+	async requeseInfo(client, game) {
+		if (game === 'csgo') {
+			return null;
+		}
+		const maxUpdateRate = await utils.rconCommand(client, 'sv_maxupdaterate');
+		return {
+			sv_maxupdaterate: maxUpdateRate,
+		};
+	},
+	setInfoMetrics(response, game) {
+		if (game !== 'csgo') {
+			const maxUpdateRate = utils.parseCvar(response.sv_maxupdaterate);
+			metrics.svMaxUpdateRate.set((Number(maxUpdateRate.value)));
+		}
+		return true;
+	},
+};

modules/index.js

@@ -0,0 +1,52 @@
+import metamod from './metamod.js';
+import sourcemod from './sourcemod.js';
+import sourcepython from './sourcepython.js';
+import registry from './registry.js';
+import game from './game.js';
+
+export default {
+	async request(config, client) {
+		let metamodResponse;
+		let sourcemodResponse;
+		let sourcepythonResponse;
+
+		const infoResponse = await game.requeseInfo(client, config.game);
+		const statsResponse = await game.requestStats(client, config.game);
+		if (config.metamod) {
+			metamodResponse = await metamod.request(client);
+		}
+		if (config.sourcemod) {
+			sourcemodResponse = await sourcemod.request(client);
+		}
+		if (config.sourcepython) {
+			sourcepythonResponse = await sourcepython.request(client);
+		}
+		return {
+			info: infoResponse,
+			stats: statsResponse,
+			metamod: metamodResponse,
+			sourcemod: sourcemodResponse,
+			sourcepython: sourcepythonResponse,
+		};
+	},
+
+	async send(config, response, res) {
+		metamod.setMetrics(response.metamod);
+		sourcemod.setMetrics(response.sourcemod);
+		sourcepython.setMetrics(response.sourcepython);
+		game.setStatsMetrics(response.stats, config.game);
+		game.setInfoMetrics(response.info, config.game);
+
+		registry.setDefaultLabels(
+			config.ip,
+			config.port,
+			config.game,
+			config.tags,
+			response.metamod,
+			response.sourcemod,
+			response.sourcepython,
+		);
+
+		registry.sendMetrics(config.game, res);
+	},
+};

modules/metamod.js

@@ -0,0 +1,17 @@
+import utils from '../utils/utils.js';
+import metrics from './metrics.js';
+
+export default {
+	async request(client) {
+		return utils.rconCommand(client, 'meta version');
+	},
+	setMetrics(response) {
+		if (response) {
+			const isEnabled = utils.isValidResponse(response);
+			const value = isEnabled ? Number(1) : Number(0);
+			metrics.metamodEnabled.set(value);
+		} else {
+			metrics.metamodEnabled.set((Number(-1)));
+		}
+	},
+};

modules/metrics.js

@@ -0,0 +1,26 @@
+import { Gauge } from 'prom-client';
+import registry from './registry.js';
+
+export default {
+	// Global metrics, used accross all Source gameservers
+	status: new Gauge({ name: 'srcds_status', help: "The server's status, 0 = offline/bad password, 1 = online", registers: registry.allGameMetrics }),
+	cpu: new Gauge({ name: 'srcds_cpu', help: 'Probably the priority level of the srcds executable from an operating system point of view (0 - No priority, 10 - biggest priority)', registers: registry.allGameMetrics }),
+	netin: new Gauge({ name: 'srcds_netin', help: 'Incoming bandwidth, in kbps, received by the server', registers: registry.allGameMetrics }),
+	netout: new Gauge({ name: 'srcds_netout', help: 'Incoming bandwidth, in kbps, sent by the server', registers: registry.allGameMetrics }),
+	uptime: new Gauge({ name: 'srcds_uptime', help: "The server's uptime, in minutes", registers: registry.allGameMetrics }),
+	maps: new Gauge({ name: 'srcds_maps', help: "The number of maps played on that server since it's start", registers: registry.allGameMetrics }),
+	fps: new Gauge({ name: 'srcds_fps', help: "The server's tick (10 fps on idle, 64 fps for 64 ticks server, 128 fps for 128 ticks..)", registers: registry.allGameMetrics }),
+	players: new Gauge({ name: 'srcds_players', help: 'The number of real players actually connected on the server', registers: registry.allGameMetrics }),
+	svMaxUpdateRate: new Gauge({ name: 'srcds_sv_max_update_rate', help: 'The time in MS per tick', registers: registry.allGameMetrics }),
+	// Metamod metrics
+	metamodEnabled: new Gauge({ name: 'srcds_metamod_enabled', help: 'Is metamod enabled', registers: registry.allGameMetrics }),
+	metamodVersion: new Gauge({ name: 'srcds_metamod_version', help: 'Metamod version', registers: registry.allGameMetrics }),
+	// Sourcemod metrics
+	sourcemodEnabled: new Gauge({ name: 'srcds_sourcemod_enabled', help: 'Is sourcemod enabled', registers: registry.allGameMetrics }),
+	// SourcePython metrics
+	sourcepythonEnabled: new Gauge({ name: 'srcds_sourcepython_enabled', help: 'Is sourcepython enabled', registers: registry.allGameMetrics }),
+
+	// CSGO metrics
+	svms: new Gauge({ name: 'srcds_svms', help: 'ms per sim frame', registers: [registry.csgoRegistry] }),
+	varms: new Gauge({ name: 'srcds_varms', help: 'ms variance', registers: [registry.csgoRegistry] }),
+};

modules/registry.js

@@ -0,0 +1,54 @@
+import prometheus from 'prom-client';
+import utils from '../utils/utils.js';
+
+const csgoRegistry = new prometheus.Registry();
+const gmodRegistry = new prometheus.Registry();
+const cstrikeRegistry = new prometheus.Registry();
+const allGameMetrics = [
+	csgoRegistry,
+	gmodRegistry,
+	cstrikeRegistry,
+];
+
+export default {
+	csgoRegistry,
+	gmodRegistry,
+	cstrikeRegistry,
+	allGameMetrics,
+
+	setDefaultLabels(ip, port, game, tags, metamodResponse, sourcemodResponse, sourcepythonResponse) {
+		const defaultLabels = { server: `${ip}:${port}`, game, tags };
+		if (metamodResponse) {
+			const line = utils.getLine(metamodResponse);
+			const version = line.replace('Metamod:Source version ', '');
+			defaultLabels.metamod = version;
+		}
+		if (sourcemodResponse) {
+			const line = utils.getLine(sourcemodResponse, 2);
+			const version = line.replace('    SourceMod Version: ', '');
+			defaultLabels.sourcemod = version;
+		}
+		if (sourcepythonResponse) {
+			const line = utils.getLine(sourcepythonResponse, 8);
+			const version = line.replace('SP version    : ', '');
+			defaultLabels.sourcepython = version;
+		}
+		if (game === 'csgo') {
+			csgoRegistry.setDefaultLabels(defaultLabels);
+		} else if (game === 'cstrike') {
+			cstrikeRegistry.setDefaultLabels(defaultLabels);
+		} else if (game === 'gmod') {
+			gmodRegistry.setDefaultLabels(defaultLabels);
+		}
+	},
+
+	sendMetrics(game, res) {
+		if (game === 'csgo') {
+			res.end(csgoRegistry.metrics());
+		} else if (game === 'cstrike') {
+			res.end(cstrikeRegistry.metrics());
+		} else if (game === 'gmod') {
+			res.end(gmodRegistry.metrics());
+		}
+	},
+};

modules/sourcemod.js

@@ -0,0 +1,17 @@
+import utils from '../utils/utils.js';
+import metrics from './metrics.js';
+
+export default {
+	async request(client) {
+		return utils.rconCommand(client, 'sm version');
+	},
+	setMetrics(response) {
+		if (response) {
+			const isEnabled = utils.isValidResponse(response);
+			const value = isEnabled ? Number(1) : Number(0);
+			metrics.sourcemodEnabled.set(value);
+		} else {
+			metrics.sourcemodEnabled.set((Number(-1)));
+		}
+	},
+};

modules/sourcepython.js

@@ -0,0 +1,17 @@
+import utils from '../utils/utils.js';
+import metrics from './metrics.js';
+
+export default {
+	async request(client) {
+		return utils.rconCommand(client, 'sp info');
+	},
+	setMetrics(response) {
+		if (response) {
+			const isEnabled = utils.isValidResponse(response);
+			const value = isEnabled ? Number(1) : Number(0);
+			metrics.sourcepythonEnabled.set(value);
+		} else {
+			metrics.sourcepythonEnabled.set(Number(-1));
+		}
+	},
+};