matterbridge 3.3.3 → 3.3.4-dev-20251020-df40d12

package/dist/utils/tracker.js

@@ -0,0 +1,201 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mTracker loaded.\u001B[40;0m');
+import os from 'node:os';
+import EventEmitter from 'node:events';
+import { AnsiLogger, BRIGHT, CYAN, RESET, YELLOW, db, RED } from 'node-ansi-logger';
+import { formatPercent, formatBytes, formatTimeStamp } from './format.js';
+export class Tracker extends EventEmitter {
+    name;
+    debug;
+    verbose;
+    trackerInterval;
+    static historyIndex = 0;
+    static historySize = 2880;
+    static history = Array.from({ length: this.historySize }, () => ({
+        timestamp: 0,
+        freeMemory: 0,
+        peakFreeMemory: 0,
+        totalMemory: 0,
+        peakTotalMemory: 0,
+        osCpu: 0,
+        peakOsCpu: 0,
+        processCpu: 0,
+        peakProcessCpu: 0,
+        rss: 0,
+        peakRss: 0,
+        heapUsed: 0,
+        peakHeapUsed: 0,
+        heapTotal: 0,
+        peakHeapTotal: 0,
+        external: 0,
+        peakExternal: 0,
+        arrayBuffers: 0,
+        peakArrayBuffers: 0,
+    }));
+    prevCpus = os.cpus();
+    prevCpuUsage = process.cpuUsage();
+    log;
+    constructor(name = 'Tracker', debug = false, verbose = false) {
+        super();
+        this.name = name;
+        this.debug = debug;
+        this.verbose = verbose;
+        if (process.argv.includes('--debug') || process.argv.includes('-debug')) {
+            this.debug = true;
+        }
+        if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
+            this.verbose = true;
+        }
+        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
+        this.log.logNameColor = YELLOW;
+        if (this.verbose) {
+            this.log.debug(`os.cpus():\n${RESET}`, os.cpus());
+            this.log.debug(`process.cpuUsage():\n${RESET}`, process.cpuUsage());
+            this.log.debug(`process.memoryUsage():\n${RESET}`, process.memoryUsage());
+        }
+        this.on('start', () => {
+            this.start();
+        });
+        this.on('stop', () => {
+            this.stop();
+        });
+        this.on('reset_peaks', () => {
+            this.resetPeaks();
+        });
+        this.on('gc', () => {
+            this.runGarbageCollector();
+        });
+    }
+    start(sampleIntervalMs = 10000) {
+        if (this.trackerInterval)
+            return;
+        this.log.debug(`Tracker starting...`);
+        let tryGcCount = 0;
+        this.prevCpus = os.cpus();
+        this.prevCpuUsage = process.cpuUsage();
+        this.trackerInterval = setInterval(() => {
+            tryGcCount += sampleIntervalMs / 1000;
+            if (tryGcCount > 60 * 60) {
+                this.runGarbageCollector();
+                tryGcCount = 0;
+            }
+            const entry = Tracker.history[Tracker.historyIndex];
+            const prevEntry = Tracker.history[(Tracker.historyIndex + Tracker.historySize - 1) % Tracker.historySize];
+            entry.timestamp = Date.now();
+            this.emit('uptime', os.uptime(), process.uptime());
+            const currentCpus = os.cpus();
+            const loads = currentCpus.map((cpu, idx) => {
+                const prev = this.prevCpus[idx]?.times;
+                if (!prev)
+                    return 0;
+                const cur = cpu.times;
+                const idleDelta = cur.idle - prev.idle;
+                const busyDelta = cur.user - prev.user + (cur.nice - prev.nice) + (cur.sys - prev.sys) + (cur.irq - prev.irq);
+                const totalDelta = busyDelta + idleDelta;
+                if (totalDelta <= 0)
+                    return 0;
+                return busyDelta / totalDelta;
+            });
+            this.prevCpus = currentCpus;
+            const avgLoad = loads.length === 0 ? 0 : loads.reduce((sum, value) => sum + value, 0) / loads.length;
+            const osCpu = Number((avgLoad * 100).toFixed(2));
+            entry.osCpu = osCpu;
+            entry.peakOsCpu = Math.max(prevEntry.peakOsCpu, osCpu);
+            const diff = process.cpuUsage(this.prevCpuUsage);
+            this.prevCpuUsage = process.cpuUsage();
+            const totalMs = (diff.user + diff.system) / 1000;
+            const processCpu = Number((((totalMs / sampleIntervalMs) * 100) / currentCpus.length).toFixed(2));
+            entry.processCpu = processCpu;
+            entry.peakProcessCpu = Math.max(prevEntry.peakProcessCpu, processCpu);
+            this.emit('cpu', entry.osCpu, entry.processCpu);
+            entry.freeMemory = os.freemem();
+            entry.peakFreeMemory = Math.max(prevEntry.peakFreeMemory, entry.freeMemory);
+            entry.totalMemory = os.totalmem();
+            entry.peakTotalMemory = Math.max(prevEntry.peakTotalMemory, entry.totalMemory);
+            const mem = process.memoryUsage();
+            entry.rss = mem.rss;
+            entry.peakRss = Math.max(prevEntry.peakRss, mem.rss);
+            entry.heapUsed = mem.heapUsed;
+            entry.peakHeapUsed = Math.max(prevEntry.peakHeapUsed, mem.heapUsed);
+            entry.heapTotal = mem.heapTotal;
+            entry.peakHeapTotal = Math.max(prevEntry.peakHeapTotal, mem.heapTotal);
+            entry.external = mem.external;
+            entry.peakExternal = Math.max(prevEntry.peakExternal, mem.external);
+            entry.arrayBuffers = mem.arrayBuffers;
+            entry.peakArrayBuffers = Math.max(prevEntry.peakArrayBuffers, mem.arrayBuffers);
+            this.emit('memory', entry.freeMemory, entry.totalMemory, entry.rss, entry.heapUsed, entry.heapTotal, entry.external, entry.arrayBuffers);
+            this.emit('snapshot', entry);
+            if (this.debug) {
+                this.log.debug(`Time: ${formatTimeStamp(entry.timestamp)} ` +
+                    `os ${CYAN}${BRIGHT}${formatPercent(entry.osCpu)}${RESET}${db} (${entry.peakOsCpu > prevEntry.peakOsCpu ? RED : ''}${formatPercent(entry.peakOsCpu)}${db}) ` +
+                    `process ${CYAN}${BRIGHT}${formatPercent(entry.processCpu)}${RESET}${db} (${entry.peakProcessCpu > prevEntry.peakProcessCpu ? RED : ''}${formatPercent(entry.peakProcessCpu)}${db}) ` +
+                    `rss: ${CYAN}${BRIGHT}${formatBytes(entry.rss)}${RESET}${db} (${entry.peakRss > prevEntry.peakRss ? RED : ''}${formatBytes(entry.peakRss)}${db}) ` +
+                    `heapUsed: ${CYAN}${BRIGHT}${formatBytes(entry.heapUsed)}${RESET}${db} (${entry.peakHeapUsed > prevEntry.peakHeapUsed ? RED : ''}${formatBytes(entry.peakHeapUsed)}${db}) ` +
+                    `heapTotal: ${CYAN}${BRIGHT}${formatBytes(entry.heapTotal)}${RESET}${db} (${entry.peakHeapTotal > prevEntry.peakHeapTotal ? RED : ''}${formatBytes(entry.peakHeapTotal)}${db}) ` +
+                    `external: ${CYAN}${BRIGHT}${formatBytes(entry.external)}${RESET}${db} (${entry.peakExternal > prevEntry.peakExternal ? RED : ''}${formatBytes(entry.peakExternal)}${db}) ` +
+                    `arrayBuffers: ${CYAN}${BRIGHT}${formatBytes(entry.arrayBuffers)}${RESET}${db} (${entry.peakArrayBuffers > prevEntry.peakArrayBuffers ? RED : ''}${formatBytes(entry.peakArrayBuffers)}${db})`);
+            }
+            Tracker.historyIndex = (Tracker.historyIndex + 1) % Tracker.historySize;
+        }, sampleIntervalMs);
+        this.log.debug(`Tracker started`);
+    }
+    resetPeaks() {
+        const prevHistoryIndex = (Tracker.historyIndex + Tracker.historySize - 1) % Tracker.historySize;
+        Tracker.history[prevHistoryIndex].peakOsCpu = 0;
+        Tracker.history[prevHistoryIndex].peakProcessCpu = 0;
+        Tracker.history[prevHistoryIndex].peakRss = 0;
+        Tracker.history[prevHistoryIndex].peakHeapUsed = 0;
+        Tracker.history[prevHistoryIndex].peakHeapTotal = 0;
+        Tracker.history[prevHistoryIndex].peakExternal = 0;
+        Tracker.history[prevHistoryIndex].peakArrayBuffers = 0;
+        if (this.debug)
+            this.log.debug(`${CYAN}${BRIGHT}Peaks reset at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
+        this.emit('reset_peaks_done');
+    }
+    runGarbageCollector(type = 'major', execution = 'async') {
+        if (global.gc && typeof global.gc === 'function') {
+            try {
+                global.gc({ type, execution });
+                if (this.debug)
+                    this.log.debug(`${CYAN}${BRIGHT}Garbage collection (${type}-${execution}) triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
+                this.emit('gc_done', type, execution);
+            }
+            catch {
+                global.gc();
+                if (this.debug)
+                    this.log.debug(`${CYAN}${BRIGHT}Garbage collection (minor-async) triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
+                this.emit('gc_done', 'minor', 'async');
+            }
+        }
+        else {
+            if (this.debug)
+                this.log.debug(`${CYAN}${BRIGHT}Garbage collection not exposed. Start Node.js with --expose-gc to enable manual garbage collection.${RESET}${db}`);
+        }
+    }
+    stop() {
+        this.log.debug(`Tracker stopping...`);
+        if (this.trackerInterval) {
+            clearInterval(this.trackerInterval);
+            this.trackerInterval = undefined;
+        }
+        if (this.debug) {
+            this.log.debug(`Tracker history for ${YELLOW}${BRIGHT}${this.name}:${RESET}`);
+            this.log.debug('Timestamp            Host cpu            Process cpu         Rss                   Heap Used             Heap Total            External              ArrayBuffers');
+            for (let i = 0; i < Tracker.historySize; i++) {
+                const index = (Tracker.historyIndex + i) % Tracker.historySize;
+                const entry = Tracker.history[index];
+                if (entry.timestamp === 0)
+                    continue;
+                this.log.debug(`${formatTimeStamp(entry.timestamp)} ` +
+                    `${CYAN}${BRIGHT}${formatPercent(entry.osCpu).padStart(8)}${RESET} (${formatPercent(entry.peakOsCpu).padStart(8)}) ` +
+                    `${CYAN}${BRIGHT}${formatPercent(entry.processCpu).padStart(8)}${RESET} (${formatPercent(entry.peakProcessCpu).padStart(8)}) ` +
+                    `${CYAN}${BRIGHT}${formatBytes(entry.rss).padStart(9)}${RESET} (${formatBytes(entry.peakRss).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${formatBytes(entry.heapUsed).padStart(9)}${RESET} (${formatBytes(entry.peakHeapUsed).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${formatBytes(entry.heapTotal).padStart(9)}${RESET} (${formatBytes(entry.peakHeapTotal).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${formatBytes(entry.external).padStart(9)}${RESET} (${formatBytes(entry.peakExternal).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${formatBytes(entry.arrayBuffers).padStart(9)}${RESET} (${formatBytes(entry.peakArrayBuffers).padStart(9)})`);
+            }
+        }
+        this.log.debug(`Tracker stopped`);
+    }
+}

package/dist/utils/wait.js

@@ -1,41 +1,6 @@
-/**
- * This file contains the wait, waiter and withTimeout functions.
- *
- * @file wait.ts
- * @author Luca Liguori
- * @created 2025-02-16
- * @version 1.0.2
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// AnsiLogger module
 import { AnsiLogger } from 'node-ansi-logger';
-/**
- * Asynchronous waiter function that resolves when the provided condition is met or rejects on timeout.
- *
- * @param {string} name - The name of the waiter.
- * @param {() => boolean} check - A function that checks the condition. Should return a boolean.
- * @param {boolean} [exitWithReject] - Optional. If true, the promise will be rejected on timeout. Default is false.
- * @param {number} [resolveTimeout] - Optional. The timeout duration in milliseconds. Default is 5000ms.
- * @param {number} [resolveInterval] - Optional. The interval duration in milliseconds between condition checks. Default is 500ms.
- * @param {boolean} [debug] - Optional. If true, debug messages will be logged to the console. Default is false.
- * @returns {Promise<boolean>} A promise that resolves to true when the condition is met, or false if the timeout occurs.
- */
 export async function waiter(name, check, exitWithReject = false, resolveTimeout = 5000, resolveInterval = 500, debug = false) {
-    const log = new AnsiLogger({ logName: 'Waiter', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "debug" /* LogLevel.DEBUG */ });
+    const log = new AnsiLogger({ logName: 'Waiter', logTimestampFormat: 4, logLevel: "debug" });
     if (check()) {
         if (debug)
             log.debug(`Waiter "${name}" already true`);
@@ -66,16 +31,8 @@ export async function waiter(name, check, exitWithReject = false, resolveTimeout
         }, resolveInterval).unref();
     });
 }
-/**
- * Asynchronously waits for a specified amount of time.
- *
- * @param {number} timeout - The duration to wait in milliseconds. Default is 1000ms.
- * @param {string} name - The name of the wait operation. Default is undefined.
- * @param {boolean} debug - Whether to enable debug logging. Default is false.
- * @returns {Promise<void>} A Promise that resolves after the specified timeout.
- */
 export async function wait(timeout = 1000, name, debug = false) {
-    const log = new AnsiLogger({ logName: 'Wait', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "debug" /* LogLevel.DEBUG */ });
+    const log = new AnsiLogger({ logName: 'Wait', logTimestampFormat: 4, logLevel: "debug" });
     if (debug)
         log.debug(`Wait "${name}" started...`);
     return new Promise((resolve) => {
@@ -87,14 +44,6 @@ export async function wait(timeout = 1000, name, debug = false) {
         }, timeout).unref();
     });
 }
-/**
- * Wraps a promise with a timeout. If the promise does not resolve or reject within the specified time, it will be rejected.
- *
- * @param {Promise<T>} promise - The promise to wrap.
- * @param {number} [timeoutMillisecs] - The timeout duration in milliseconds. Default is 10000ms.
- * @param {boolean} [reThrow] - Optional. If true, the promise will rethrow the original promise and will reject on timeout. Default is true.
- * @returns {Promise<T>} A new promise that resolves or rejects based on the original promise and the timeout.
- */
 export function withTimeout(promise, timeoutMillisecs = 10000, reThrow = true) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -102,24 +51,23 @@ export function withTimeout(promise, timeoutMillisecs = 10000, reThrow = true) {
                 reject(new Error('Operation timed out'));
             }
             else {
-                resolve(undefined); // Resolve with undefined if reThrow is false
+                resolve(undefined);
             }
-        }, timeoutMillisecs).unref(); // Unref the timer to prevent it from keeping the event loop alive
+        }, timeoutMillisecs).unref();
         promise
             .then((result) => {
-            clearTimeout(timer); // Ensure timeout does not fire if promise resolves first
+            clearTimeout(timer);
             resolve(result);
             return result;
         })
             .catch((error) => {
-            clearTimeout(timer); // Ensure timeout does not fire if promise rejects first
+            clearTimeout(timer);
             if (reThrow) {
-                reject(error); // Reject with the original error
+                reject(error);
             }
             else {
-                resolve(undefined); // Resolve with undefined if reThrow is false
+                resolve(undefined);
             }
         });
     });
 }
-//# sourceMappingURL=wait.js.map