refactor: rename builders to server

packages/server/src/monitoring/utilts.ts

@@ -0,0 +1,198 @@
+import { promises } from "node:fs";
+import type Dockerode from "dockerode";
+import osUtils from "node-os-utils";
+import { paths } from "../constants";
+
+export const recordAdvancedStats = async (
+	stats: Dockerode.ContainerStats,
+	appName: string,
+) => {
+	const { MONITORING_PATH } = paths();
+	const path = `${MONITORING_PATH}/${appName}`;
+
+	await promises.mkdir(path, { recursive: true });
+
+	const cpuPercent = calculateCpuUsagePercent(
+		stats.cpu_stats,
+		stats.precpu_stats,
+	);
+	const memoryStats = calculateMemoryStats(stats.memory_stats);
+	const blockIO = calculateBlockIO(stats.blkio_stats);
+	const networkUsage = calculateNetworkUsage(stats.networks);
+
+	await updateStatsFile(appName, "cpu", cpuPercent);
+	await updateStatsFile(appName, "memory", {
+		used: memoryStats.used,
+		free: memoryStats.free,
+		usedPercentage: memoryStats.usedPercentage,
+		total: memoryStats.total,
+	});
+	await updateStatsFile(appName, "block", {
+		readMb: blockIO.readMb,
+		writeMb: blockIO.writeMb,
+	});
+
+	await updateStatsFile(appName, "network", {
+		inputMb: networkUsage.inputMb,
+		outputMb: networkUsage.outputMb,
+	});
+
+	if (appName === "dokploy") {
+		const disk = await osUtils.drive.info("/");
+
+		const diskUsage = disk.usedGb;
+		const diskTotal = disk.totalGb;
+		const diskUsedPercentage = disk.usedPercentage;
+		const diskFree = disk.freeGb;
+
+		await updateStatsFile(appName, "disk", {
+			diskTotal: +diskTotal,
+			diskUsedPercentage: +diskUsedPercentage,
+			diskUsage: +diskUsage,
+			diskFree: +diskFree,
+		});
+	}
+};
+
+export const getAdvancedStats = async (appName: string) => {
+	return {
+		cpu: await readStatsFile(appName, "cpu"),
+		memory: await readStatsFile(appName, "memory"),
+		disk: await readStatsFile(appName, "disk"),
+		network: await readStatsFile(appName, "network"),
+		block: await readStatsFile(appName, "block"),
+	};
+};
+
+export const readStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+) => {
+	try {
+		const { MONITORING_PATH } = paths();
+		const filePath = `${MONITORING_PATH}/${appName}/${statType}.json`;
+		const data = await promises.readFile(filePath, "utf-8");
+		return JSON.parse(data);
+	} catch (error) {
+		return [];
+	}
+};
+
+export const updateStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+	value: number | string | unknown,
+) => {
+	const { MONITORING_PATH } = paths();
+	const stats = await readStatsFile(appName, statType);
+	stats.push({ value, time: new Date() });
+
+	if (stats.length > 288) {
+		stats.shift();
+	}
+
+	const content = JSON.stringify(stats);
+	await promises.writeFile(
+		`${MONITORING_PATH}/${appName}/${statType}.json`,
+		content,
+	);
+};
+
+export const readLastValueStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+) => {
+	try {
+		const { MONITORING_PATH } = paths();
+		const filePath = `${MONITORING_PATH}/${appName}/${statType}.json`;
+		const data = await promises.readFile(filePath, "utf-8");
+		const stats = JSON.parse(data);
+		return stats[stats.length - 1] || null;
+	} catch (error) {
+		return null;
+	}
+};
+
+export const getLastAdvancedStatsFile = async (appName: string) => {
+	return {
+		cpu: await readLastValueStatsFile(appName, "cpu"),
+		memory: await readLastValueStatsFile(appName, "memory"),
+		disk: await readLastValueStatsFile(appName, "disk"),
+		network: await readLastValueStatsFile(appName, "network"),
+		block: await readLastValueStatsFile(appName, "block"),
+	};
+};
+
+const calculateCpuUsagePercent = (
+	cpu_stats: Dockerode.ContainerStats["cpu_stats"],
+	precpu_stats: Dockerode.ContainerStats["precpu_stats"],
+) => {
+	const cpuDelta =
+		cpu_stats.cpu_usage.total_usage - precpu_stats.cpu_usage.total_usage;
+	const systemDelta =
+		cpu_stats.system_cpu_usage - precpu_stats.system_cpu_usage;
+
+	const numberCpus =
+		cpu_stats.online_cpus ||
+		(cpu_stats.cpu_usage.percpu_usage
+			? cpu_stats.cpu_usage.percpu_usage.length
+			: 1);
+
+	if (systemDelta > 0 && cpuDelta > 0) {
+		return (cpuDelta / systemDelta) * numberCpus * 100.0;
+	}
+	return 0;
+};
+
+const calculateMemoryStats = (
+	memory_stats: Dockerode.ContainerStats["memory_stats"],
+) => {
+	const usedMemory = memory_stats.usage - (memory_stats.stats.cache || 0);
+	const availableMemory = memory_stats.limit;
+	const memoryUsedPercentage = (usedMemory / availableMemory) * 100.0;
+
+	return {
+		used: usedMemory,
+		free: availableMemory - usedMemory,
+		usedPercentage: memoryUsedPercentage,
+		total: availableMemory,
+	};
+};
+const calculateBlockIO = (
+	blkio_stats: Dockerode.ContainerStats["blkio_stats"],
+) => {
+	let readIO = 0;
+	let writeIO = 0;
+	if (blkio_stats?.io_service_bytes_recursive) {
+		for (const io of blkio_stats.io_service_bytes_recursive) {
+			if (io.op === "read") {
+				readIO += io.value;
+			} else if (io.op === "write") {
+				writeIO += io.value;
+			}
+		}
+	}
+	return {
+		readMb: readIO / (1024 * 1024),
+		writeMb: writeIO / (1024 * 1024),
+	};
+};
+
+const calculateNetworkUsage = (
+	networks: Dockerode.ContainerStats["networks"],
+) => {
+	let totalRx = 0;
+	let totalTx = 0;
+
+	const stats = Object.keys(networks);
+
+	for (const interfaceName of stats) {
+		const net = networks[interfaceName];
+		totalRx += net?.rx_bytes || 0;
+		totalTx += net?.tx_bytes || 0;
+	}
+	return {
+		inputMb: totalRx / (1024 * 1024),
+		outputMb: totalTx / (1024 * 1024),
+	};
+};