@arcblock/pm2-prom-module 2.6.1

package/metrics/index.js

@@ -0,0 +1,234 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePromAppInstancesMetrics = exports.deletePromAppMetrics = exports.combineAllRegistries = exports.initDynamicGaugeMetricClients = exports.initMetrics = exports.dynamicGaugeMetricClients = exports.metricAppStatus = exports.metricAppPidsMemory = exports.metricAppUptime = exports.metricAppRestartCount = exports.metricAppPidsCpuThreshold = exports.metricAppPidsCpuLast = exports.metricAppAverageCpu = exports.metricAppTotalMemory = exports.metricAppAverageMemory = exports.metricAppInstances = exports.metricAvailableApps = exports.registry = void 0;
+const prom_client_1 = __importDefault(require("prom-client"));
+const node_os_1 = __importDefault(require("node:os"));
+const cpu_1 = require("../utils/cpu");
+const docker_1 = require("../utils/docker");
+const app_1 = require("./app");
+const METRIC_FREE_MEMORY = 'free_memory';
+const METRIC_AVAILABLE_CPU = 'cpu_count';
+const METRIC_AVAILABLE_APPS = 'available_apps';
+const METRIC_APP_INSTANCES = 'app_instances';
+const METRIC_APP_AVERAGE_MEMORY = 'app_average_memory';
+const METRIC_APP_PIDS_MEMORY = 'app_pids_memory';
+const METRIC_APP_TOTAL_MEMORY = 'app_total_memory';
+const METRIC_APP_AVERAGE_CPU = 'app_average_cpu';
+const METRIC_APP_PIDS_CPU = 'app_pids_cpu';
+const METRIC_APP_PIDS_CPU_THRESHOLD = 'app_pids_cpu_threshold';
+const METRIC_APP_RESTART_COUNT = 'app_restart_count';
+const METRIC_APP_UPTIME = 'app_uptime';
+const METRIC_APP_STATUS = 'app_status';
+const METRIC_TOTAL_MEMORY_CONTAINER = 'container_total_memory';
+const METRIC_FREE_MEMORY_CONTAINER = 'container_free_memory';
+const METRIC_USED_MEMORY_CONTAINER = 'container_used_memory';
+const METRIC_AVAILABLE_CPU_CONTAINER = 'container_cpu_count';
+exports.registry = new prom_client_1.default.Registry();
+let currentPrefix = '';
+exports.dynamicGaugeMetricClients = {};
+// Metrics
+const initMetrics = (prefix) => {
+    currentPrefix = prefix;
+    new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_FREE_MEMORY}`,
+        help: 'Show available host free memory (System OS)',
+        collect() {
+            this.set(node_os_1.default.freemem());
+        },
+        registers: [exports.registry],
+    });
+    new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_AVAILABLE_CPU}`,
+        help: 'Show available CPUs count (System OS)',
+        collect() {
+            this.set((0, cpu_1.getCpuCount)());
+        },
+        registers: [exports.registry],
+    });
+    // Check if we in docker container
+    (0, docker_1.hasDockerLimitFiles)()
+        .then(() => {
+        new prom_client_1.default.Gauge({
+            name: `${prefix}_${METRIC_TOTAL_MEMORY_CONTAINER}`,
+            help: 'Available memory in container',
+            collect() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const memory = yield (0, docker_1.getAvailableMemory)();
+                        this.set(memory);
+                    }
+                    catch (_a) { }
+                });
+            },
+            registers: [exports.registry],
+        });
+        new prom_client_1.default.Gauge({
+            name: `${prefix}_${METRIC_FREE_MEMORY_CONTAINER}`,
+            help: 'Free memory in container',
+            collect() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const memory = yield (0, docker_1.getFreeMemory)();
+                        this.set(memory);
+                    }
+                    catch (_a) { }
+                });
+            },
+            registers: [exports.registry],
+        });
+        new prom_client_1.default.Gauge({
+            name: `${prefix}_${METRIC_USED_MEMORY_CONTAINER}`,
+            help: 'Used memory in container',
+            collect() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const memory = yield (0, docker_1.getUsedMemory)();
+                        this.set(memory);
+                    }
+                    catch (_a) { }
+                });
+            },
+            registers: [exports.registry],
+        });
+        new prom_client_1.default.Gauge({
+            name: `${prefix}_${METRIC_AVAILABLE_CPU_CONTAINER}`,
+            help: 'Available CPUs limit in container',
+            collect() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const limit = yield (0, docker_1.getCPULimit)();
+                        this.set(limit);
+                    }
+                    catch (_a) { }
+                });
+            },
+            registers: [exports.registry],
+        });
+    })
+        .catch(() => {
+        //
+    });
+    exports.metricAvailableApps = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_AVAILABLE_APPS}`,
+        help: 'Show available apps to monitor',
+        registers: [exports.registry],
+    });
+    // Specific app metrics
+    exports.metricAppInstances = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_INSTANCES}`,
+        help: 'Show app instances count',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    exports.metricAppAverageMemory = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_AVERAGE_MEMORY}`,
+        help: 'Show average using memory of an app',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    exports.metricAppTotalMemory = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_TOTAL_MEMORY}`,
+        help: 'Show total using memory of an app',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    exports.metricAppAverageCpu = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_AVERAGE_CPU}`,
+        help: 'Show average app cpu usage',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    exports.metricAppUptime = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_UPTIME}`,
+        help: 'Show app uptime in seconds',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    exports.metricAppStatus = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_STATUS}`,
+        help: 'Current App status. (0-unknown,1-running,2-pending,3-stopped,4-errored)',
+        registers: [exports.registry],
+        labelNames: ['app'],
+    });
+    // Metrics with instances
+    exports.metricAppPidsCpuLast = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_PIDS_CPU}`,
+        help: 'Show current (last) usage CPU for every app instance',
+        registers: [exports.registry],
+        labelNames: ['app', 'instance'],
+    });
+    exports.metricAppPidsCpuThreshold = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_PIDS_CPU_THRESHOLD}`,
+        help: 'Show average CPU for every app instance to detect autoscale if module exists',
+        registers: [exports.registry],
+        labelNames: ['app', 'instance'],
+    });
+    exports.metricAppRestartCount = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_RESTART_COUNT}`,
+        help: 'Show restart count of the app',
+        registers: [exports.registry],
+        labelNames: ['app', 'instance'],
+    });
+    exports.metricAppPidsMemory = new prom_client_1.default.Gauge({
+        name: `${prefix}_${METRIC_APP_PIDS_MEMORY}`,
+        help: 'Show current usage memory for every app instance',
+        registers: [exports.registry],
+        labelNames: ['app', 'instance'],
+    });
+};
+exports.initMetrics = initMetrics;
+const initDynamicGaugeMetricClients = (metrics) => {
+    metrics.forEach((entry) => {
+        exports.dynamicGaugeMetricClients[entry.key] = new prom_client_1.default.Gauge({
+            name: `${currentPrefix}_${entry.key}`,
+            help: entry.description,
+            registers: [exports.registry],
+            labelNames: ['app', 'instance'],
+        });
+    });
+};
+exports.initDynamicGaugeMetricClients = initDynamicGaugeMetricClients;
+const combineAllRegistries = (needAggregate) => {
+    const appRegistry = (0, app_1.getAppRegistry)(needAggregate);
+    if (appRegistry) {
+        return prom_client_1.default.Registry.merge([exports.registry, appRegistry]);
+    }
+    else {
+        return exports.registry;
+    }
+};
+exports.combineAllRegistries = combineAllRegistries;
+const deletePromAppMetrics = (appName, instances) => {
+    exports.metricAppInstances === null || exports.metricAppInstances === void 0 ? void 0 : exports.metricAppInstances.remove(appName);
+    exports.metricAppAverageMemory === null || exports.metricAppAverageMemory === void 0 ? void 0 : exports.metricAppAverageMemory.remove(appName);
+    exports.metricAppTotalMemory === null || exports.metricAppTotalMemory === void 0 ? void 0 : exports.metricAppTotalMemory.remove(appName);
+    exports.metricAppAverageCpu === null || exports.metricAppAverageCpu === void 0 ? void 0 : exports.metricAppAverageCpu.remove(appName);
+    exports.metricAppUptime === null || exports.metricAppUptime === void 0 ? void 0 : exports.metricAppUptime.remove(appName);
+    exports.metricAppStatus === null || exports.metricAppStatus === void 0 ? void 0 : exports.metricAppStatus.remove(appName);
+    (0, exports.deletePromAppInstancesMetrics)(appName, instances);
+};
+exports.deletePromAppMetrics = deletePromAppMetrics;
+const deletePromAppInstancesMetrics = (appName, instances) => {
+    instances.forEach((pmId) => {
+        exports.metricAppPidsCpuLast === null || exports.metricAppPidsCpuLast === void 0 ? void 0 : exports.metricAppPidsCpuLast.remove({ app: appName, instance: pmId });
+        exports.metricAppPidsCpuThreshold === null || exports.metricAppPidsCpuThreshold === void 0 ? void 0 : exports.metricAppPidsCpuThreshold.remove({ app: appName, instance: pmId });
+        exports.metricAppRestartCount === null || exports.metricAppRestartCount === void 0 ? void 0 : exports.metricAppRestartCount.remove({ app: appName, instance: pmId });
+        exports.metricAppPidsMemory === null || exports.metricAppPidsMemory === void 0 ? void 0 : exports.metricAppPidsMemory.remove({ app: appName, instance: pmId });
+        for (const [, entry] of Object.entries(exports.dynamicGaugeMetricClients)) {
+            entry === null || entry === void 0 ? void 0 : entry.remove({ app: appName, instance: pmId });
+        }
+    });
+};
+exports.deletePromAppInstancesMetrics = deletePromAppInstancesMetrics;

package/metrics/prom/histogram.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHistogramBuckets = exports.IHistogram = void 0;
+const prom_client_1 = __importDefault(require("prom-client"));
+class IHistogram extends prom_client_1.default.Histogram {
+    constructor() {
+        super(...arguments);
+        this.values = {};
+    }
+    setValues(defaultLabels, values) {
+        let valueKey = '';
+        for (const [key, value] of Object.entries(defaultLabels)) {
+            valueKey += `${key}:${value};`;
+        }
+        this.values[valueKey] = values.map((entry) => {
+            const newEntry = Object.assign({}, entry);
+            const labels = Object.assign(Object.assign({}, entry.labels), defaultLabels);
+            newEntry.labels = labels;
+            return newEntry;
+        });
+    }
+    getForPromString() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = [];
+            for (const [, entries] of Object.entries(this.values)) {
+                entries.forEach((value) => values.push(value));
+            }
+            return {
+                name: this.name,
+                help: this.help,
+                type: this.type,
+                values,
+                aggregator: this.aggregator,
+            };
+        });
+    }
+}
+exports.IHistogram = IHistogram;
+const getHistogramBuckets = (values) => {
+    const labels = new Set();
+    values.forEach((entry) => {
+        Object.keys(entry.labels).forEach((label) => {
+            if (label === 'le' && entry.labels[label] !== '+Inf') {
+                labels.add(Number(entry.labels[label]));
+            }
+        });
+    });
+    return Array.from(labels);
+};
+exports.getHistogramBuckets = getHistogramBuckets;

package/metrics/prom/summary.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISummary = void 0;
+const prom_client_1 = __importDefault(require("prom-client"));
+class ISummary extends prom_client_1.default.Summary {
+    constructor() {
+        super(...arguments);
+        this.values = {};
+    }
+    setValues(defaultLabels, values) {
+        let valueKey = '';
+        for (const [key, value] of Object.entries(defaultLabels)) {
+            valueKey += `${key}:${value};`;
+        }
+        this.values[valueKey] = values.map((entry) => {
+            const newEntry = Object.assign({}, entry);
+            const labels = Object.assign(Object.assign({}, entry.labels), defaultLabels);
+            newEntry.labels = labels;
+            return newEntry;
+        });
+    }
+    get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = [];
+            for (const [, entries] of Object.entries(this.values)) {
+                entries.forEach((value) => values.push(value));
+            }
+            return {
+                name: this.name,
+                help: this.help,
+                type: this.type,
+                values,
+                aggregator: this.aggregator,
+                collect: () => __awaiter(this, void 0, void 0, function* () { }),
+            };
+        });
+    }
+}
+exports.ISummary = ISummary;

package/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "@arcblock/pm2-prom-module",
+    "version": "2.6.1",
+    "publishConfig": {
+        "access": "public"
+    },
+    "description": "PM2 module to help collect applications statistic and send it to Prometheus server",
+    "main": "index.js",
+    "dependencies": {
+        "pidusage": "^3.0.2",
+        "pm2": "^5.3.0",
+        "pmx": "beta",
+        "prom-client": "^15.1.3",
+        "xbytes": "^1.9.1",
+        "zx": "^4.3.0"
+    },
+    "scripts": {
+        "predev": "pm2 delete pm2-prom-module || true && npm run build",
+        "dev": "pm2 install .",
+        "build": "tsc -p tsconfig.json",
+        "watch": "tsc -w -p tsconfig.json",
+        "release": "npm run build && npm publish",
+        "bump:version": "zx scripts/bump-version.mjs --quiet"
+    },
+    "files": [
+        "README.md",
+        "**/*.js"
+    ],
+    "apps": [
+        {
+            "merge_logs": true,
+            "max_memory_restart": "1024M",
+            "script": "index.js"
+        }
+    ],
+    "config": {
+        "port": "9988",
+        "hostname": "0.0.0.0",
+        "unix_socket_path": "",
+        "service_name": "",
+        "debug": false,
+        "aggregate_app_metrics": true,
+        "app_check_interval": 1000,
+        "prefix": "pm2"
+    },
+    "devDependencies": {
+        "@types/node": "^18.19.50",
+        "@types/pidusage": "^2.0.5",
+        "bumpp": "^10.1.0",
+        "typescript": "^5.3.3"
+    },
+    "engines": {
+        "node": ">=14"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/VeXell/pm2-prom-module.git"
+    },
+    "author": "Viacheslav Volkov (vexell@gmail.com)",
+    "license": "MIT",
+    "keywords": [
+        "PM2",
+        "Prometheus",
+        "Metrics",
+        "Monitoring",
+        "Prom client",
+        "Module",
+        "Node.js",
+        "Javascript"
+    ]
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/cpu.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPidsUsage = exports.getCpuCount = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const pidusage_1 = __importDefault(require("pidusage"));
+// We also get it from nproc and use the minimum of the two.
+const getConcurrencyFromNProc = () => {
+    try {
+        return parseInt((0, node_child_process_1.execSync)('nproc', { stdio: 'pipe' }).toString().trim(), 10);
+    }
+    catch (error) {
+        return null;
+    }
+};
+const getCpuCount = () => {
+    if (node_os_1.default.availableParallelism) {
+        return node_os_1.default.availableParallelism();
+    }
+    const node = node_os_1.default.cpus().length;
+    const nproc = getConcurrencyFromNProc();
+    if (nproc === null) {
+        return node;
+    }
+    return Math.min(nproc, node);
+};
+exports.getCpuCount = getCpuCount;
+const getPidsUsage = (pids) => {
+    return new Promise((resolve, reject) => {
+        if (pids.length) {
+            (0, pidusage_1.default)(pids, (err, stats) => {
+                if (err) {
+                    reject(err);
+                }
+                resolve(stats);
+            });
+        }
+        else {
+            resolve({});
+        }
+    });
+};
+exports.getPidsUsage = getPidsUsage;

package/utils/docker.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDockerStats = exports.getCPULimit = exports.getFreeMemory = exports.getUsedMemory = exports.getAvailableMemory = exports.hasDockerLimitFiles = void 0;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const cpu_1 = require("./cpu");
+const zx_1 = require("zx");
+const xbytes_1 = __importDefault(require("xbytes"));
+// 禁用命令和结果的自动输出
+zx_1.$.verbose = false;
+//const MEMORY_AVAILABLE = '/sys/fs/cgroup/memory.limit_in_bytes';
+//const MEMORY_USED = '/sys/fs/cgroup/memory.usage_in_bytes';
+const MEMORY_AVAILABLE = '/sys/fs/cgroup/memory.max';
+const MEMORY_USED = '/sys/fs/cgroup/memory.current';
+const CPUS_LIMIT = '/sys/fs/cgroup/cpu.max';
+const hasDockerLimitFiles = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, promises_1.access)(MEMORY_AVAILABLE, promises_1.constants.R_OK);
+});
+exports.hasDockerLimitFiles = hasDockerLimitFiles;
+const getAvailableMemory = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = (yield (0, promises_1.readFile)(MEMORY_AVAILABLE, { encoding: 'utf8' })).trim();
+        if (data === 'max') {
+            return node_os_1.default.totalmem();
+        }
+        else {
+            const memoryNumber = parseInt(data, 10);
+            if (isNaN(memoryNumber)) {
+                return 0;
+            }
+            else {
+                return memoryNumber;
+            }
+        }
+    }
+    catch (_a) {
+        return 0;
+    }
+});
+exports.getAvailableMemory = getAvailableMemory;
+const getUsedMemory = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = (yield (0, promises_1.readFile)(MEMORY_USED, { encoding: 'utf8' })).trim();
+        const usedMemory = parseInt(data, 10);
+        if (isNaN(usedMemory)) {
+            return 0;
+        }
+        else {
+            return usedMemory;
+        }
+    }
+    catch (_b) {
+        return 0;
+    }
+});
+exports.getUsedMemory = getUsedMemory;
+const getFreeMemory = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = (yield (0, promises_1.readFile)(MEMORY_AVAILABLE, { encoding: 'utf8' })).trim();
+        const systemFreeMem = node_os_1.default.freemem();
+        if (data === 'max') {
+            // In that case we do not have any limits. Use only freemem
+            return systemFreeMem;
+        }
+        // In that case we should calculate free memory
+        const availableMemory = parseInt(data, 10);
+        if (isNaN(availableMemory)) {
+            // If we can not parse return OS Free memory
+            return systemFreeMem;
+        }
+        const usedMemory = yield (0, exports.getUsedMemory)();
+        if (availableMemory <= systemFreeMem) {
+            // We have docker limit in the container
+            return availableMemory - usedMemory;
+        }
+        else {
+            // Limited by system available memory
+            return systemFreeMem;
+        }
+    }
+    catch (_c) {
+        return 0;
+    }
+});
+exports.getFreeMemory = getFreeMemory;
+const getCPULimit = () => __awaiter(void 0, void 0, void 0, function* () {
+    let count = (0, cpu_1.getCpuCount)();
+    const delimeter = 100000;
+    try {
+        const data = (yield (0, promises_1.readFile)(CPUS_LIMIT, { encoding: 'utf8' })).trim();
+        if (data) {
+            const values = data.split(' ');
+            if (values.length === 2) {
+                const parsedValue = parseInt(values[0], 10);
+                if (!isNaN(parsedValue)) {
+                    count = parsedValue / delimeter;
+                }
+            }
+        }
+    }
+    catch (_d) { }
+    return count;
+});
+exports.getCPULimit = getCPULimit;
+function getDockerStats(ids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!ids.length) {
+                return [];
+            }
+            const result = yield (0, zx_1.$) `docker stats --no-stream --format "{{json .}}" -a`;
+            if (result.exitCode || !result.stdout) {
+                return [];
+            }
+            const statsRows = result.stdout
+                .split('\n')
+                .filter(Boolean)
+                .map((x) => JSON.parse(x));
+            const stats = statsRows.map((x) => {
+                const [memoryUsage, totalMemory] = x.MemUsage.split('/').map((x) => xbytes_1.default.parseSize(x.trim()));
+                return {
+                    name: x.Name,
+                    cpuUsage: +x.CPUPerc.replace('%', ''),
+                    memoryUsage: memoryUsage,
+                    totalMemory: totalMemory,
+                };
+            });
+            return ids.map((id) => {
+                return stats.find((x) => x.name === id);
+            });
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    });
+}
+exports.getDockerStats = getDockerStats;

package/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUndescore = void 0;
+function toUndescore(str) {
+    return str.toLowerCase().replace(/\s+/g, '_');
+}
+exports.toUndescore = toUndescore;

package/utils/logger.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.getLogger = exports.initLogger = void 0;
+class SimpleLogger {
+    constructor(isDebug = false) {
+        this.isDebug = false;
+        this.isDebug = isDebug;
+    }
+    debug(message) {
+        if (this.isDebug) {
+            const value = `DEBUG: ${message}`;
+            this.log(value);
+        }
+    }
+    error(message) {
+        const value = `ERROR: ${message}`;
+        this.logError(value);
+    }
+    info(message) {
+        const value = `INFO: ${message}`;
+        this.log(value);
+    }
+    log(message) {
+        console.log(message);
+    }
+    logError(message) {
+        console.error(message);
+    }
+}
+let loggerInstance;
+const initLogger = ({ isDebug }) => {
+    if (!loggerInstance) {
+        loggerInstance = new SimpleLogger(isDebug);
+    }
+};
+exports.initLogger = initLogger;
+const getLogger = () => {
+    if (!loggerInstance) {
+        loggerInstance = new SimpleLogger();
+    }
+    return loggerInstance;
+};
+exports.getLogger = getLogger;
+exports.logger = (0, exports.getLogger)();