matterbridge 3.3.3-dev-20251019-a73923c → 3.3.4-dev-20251020-4d2dd49

package/dist/matterbridge.js

@@ -8,7 +8,7 @@ import { inspect } from 'node:util';
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt, BLUE, or } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
 import { DeviceTypeId, Endpoint, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode, UINT32_MAX, UINT16_MAX, Crypto, } from '@matter/main';
-import { FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
+import { FabricAction, PaseClient } from '@matter/main/protocol';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
 import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
 import { getParameter, getIntParameter, hasParameter } from './utils/commandLine.js';
@@ -130,33 +130,9 @@ export class Matterbridge extends EventEmitter {
     }
     async destroyInstance(timeout = 1000, pause = 250) {
         this.log.info(`Destroy instance...`);
-        const servers = [];
-        if (this.bridgeMode === 'bridge') {
-            if (this.serverNode)
-                servers.push(this.serverNode);
-        }
-        if (this.bridgeMode === 'childbridge' && this.plugins !== undefined) {
-            for (const plugin of this.plugins.array()) {
-                if (plugin.serverNode)
-                    servers.push(plugin.serverNode);
-            }
-        }
-        if (this.devices !== undefined) {
-            for (const device of this.devices.array()) {
-                if (device.mode === 'server' && device.serverNode)
-                    servers.push(device.serverNode);
-            }
-        }
-        await Promise.resolve();
-        await wait(pause, 'destroyInstance start', true);
         await this.cleanup('destroying instance...', false, timeout);
-        this.log.info(`Dispose ${servers.length} MdnsService...`);
-        for (const server of servers) {
-            await server.env.get(MdnsService)[Symbol.asyncDispose]();
-            this.log.info(`Closed ${server.id} MdnsService`);
-        }
-        await Promise.resolve();
-        await wait(pause, 'destroyInstance stop', true);
+        if (pause)
+            await wait(pause, 'destroyInstance stop', true);
     }
     async initialize() {
         this.emit('initialize_started');
@@ -478,7 +454,7 @@ export class Matterbridge extends EventEmitter {
             `${hasParameter('controller') ? 'mode controller ' : ''}` +
             `${this.restartMode !== '' ? 'restart mode ' + this.restartMode + ' ' : ''}` +
             `running on ${this.systemInformation.osType} (v.${this.systemInformation.osRelease}) platform ${this.systemInformation.osPlatform} arch ${this.systemInformation.osArch}`);
-        const minNodeVersion = 18;
+        const minNodeVersion = 20;
         const nodeVersion = process.versions.node;
         const versionMajor = parseInt(nodeVersion.split('.')[0]);
         if (versionMajor < minNodeVersion) {
@@ -490,52 +466,6 @@ export class Matterbridge extends EventEmitter {
         this.initialized = true;
     }
     async parseCommandLine() {
-        if (hasParameter('help')) {
-            this.log.info(`\nUsage: matterbridge [options]\n
-      Options:
-      --help:                  show the help
-      --bridge:                start Matterbridge in bridge mode
-      --childbridge:           start Matterbridge in childbridge mode
-      --port [port]:           start the commissioning server on the given port (default 5540)
-      --mdnsinterface [name]:  set the interface to use for the matter server mdnsInterface (default all interfaces)
-      --ipv4address [address]: set the ipv4 interface address to use for the matter listener (default all addresses)
-      --ipv6address [address]: set the ipv6 interface address to use for the matter listener (default all addresses)
-      --frontend [port]:       start the frontend on the given port (default 8283)
-      --logger:                set the matterbridge logger level: debug | info | notice | warn | error | fatal (default info)
-      --filelogger             enable the matterbridge file logger (matterbridge.log)
-      --matterlogger:          set the matter.js logger level: debug | info | notice | warn | error | fatal (default info)
-      --matterfilelogger       enable the matter.js file logger (matter.log)
-      --reset:                 remove the commissioning for Matterbridge (bridge mode). Shutdown Matterbridge before using it!
-      --factoryreset:          remove all commissioning information and reset all internal storages. Shutdown Matterbridge before using it!
-      --list:                  list the registered plugins
-      --loginterfaces:         log the network interfaces (usefull for finding the name of the interface to use with -mdnsinterface option)
-      --logstorage:            log the node storage
-      --sudo:                  force the use of sudo to install or update packages if the internal logic fails
-      --nosudo:                force not to use sudo to install or update packages if the internal logic fails
-      --norestore:             force not to automatically restore the matterbridge node storage and the matter storage from backup if it is corrupted
-      --novirtual:             disable the creation of the virtual devices Restart, Update and Reboot Matterbridge
-      --ssl:                   enable SSL for the frontend and the WebSocketServer (the server will use the certificates and switch to https)
-      --mtls:                  enable mTLS for the frontend and the WebSocketServer (both server and client will use and require the certificates and switch to https)
-      --vendorId:              override the default vendorId 0xfff1
-      --vendorName:            override the default vendorName "Matterbridge"
-      --productId:             override the default productId 0x8000
-      --productName:           override the default productName "Matterbridge aggregator"
-      --service:               enable the service mode (used in the systemctl configuration file)
-      --docker:                enable the docker mode (used in the docker image)
-      --homedir:               override the home directory (default: os.homedir())
-      --add [plugin path]:     register the plugin from the given absolute or relative path
-      --add [plugin name]:     register the globally installed plugin with the given name
-      --remove [plugin path]:  remove the plugin from the given absolute or relative path
-      --remove [plugin name]:  remove the globally installed plugin with the given name
-      --enable [plugin path]:  enable the plugin from the given absolute or relative path
-      --enable [plugin name]:  enable the globally installed plugin with the given name
-      --disable [plugin path]: disable the plugin from the given absolute or relative path
-      --disable [plugin name]: disable the globally installed plugin with the given name
-      --reset [plugin path]:   remove the commissioning for the plugin from the given absolute or relative path (childbridge mode). Shutdown Matterbridge before using it!
-      --reset [plugin name]:   remove the commissioning for the globally installed plugin (childbridge mode). Shutdown Matterbridge before using it!${rs}`);
-            this.shutdown = true;
-            return;
-        }
         if (hasParameter('list')) {
             this.log.info(`│ Registered plugins (${this.plugins.length})`);
             let index = 0;
@@ -606,10 +536,8 @@ export class Matterbridge extends EventEmitter {
             if (this.aggregatorSerialNumber && this.aggregatorUniqueId && this.matterStorageService) {
                 const storageManager = await this.matterStorageService.open('Matterbridge');
                 const storageContext = storageManager?.createContext('persist');
-                if (this.aggregatorSerialNumber)
-                    await storageContext?.set('serialNumber', this.aggregatorSerialNumber);
-                if (this.aggregatorUniqueId)
-                    await storageContext?.set('uniqueId', this.aggregatorUniqueId);
+                await storageContext?.set('serialNumber', this.aggregatorSerialNumber);
+                await storageContext?.set('uniqueId', this.aggregatorUniqueId);
             }
         }
         catch (error) {

package/dist/utils/commandLine.js

@@ -1,4 +1,4 @@
-import { isValidNumber } from './export.js';
+import { isValidNumber } from './isvalid.js';
 export function hasParameter(name) {
     const commandArguments = process.argv.slice(2);
     let markerIncluded = commandArguments.includes(`-${name}`);
@@ -6,6 +6,11 @@ export function hasParameter(name) {
         markerIncluded = commandArguments.includes(`--${name}`);
     return markerIncluded;
 }
+export function hasAnyParameter(...params) {
+    return params.some((param) => {
+        return hasParameter(param);
+    });
+}
 export function getParameter(name) {
     const commandArguments = process.argv.slice(2);
     let markerIndex = commandArguments.indexOf(`-${name}`);

package/dist/utils/inspector.js

@@ -0,0 +1,200 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mInspector loaded.\u001B[40;0m');
+import EventEmitter from 'node:events';
+import { AnsiLogger, BRIGHT, CYAN, RESET, YELLOW, db } from 'node-ansi-logger';
+export class Inspector extends EventEmitter {
+    name;
+    debug;
+    verbose;
+    session;
+    snapshotInterval;
+    snapshotInProgress = false;
+    log;
+    constructor(name = 'Inspector', 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: this.name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
+        this.log.logNameColor = YELLOW;
+        this.on('start', () => {
+            this.start();
+        });
+        this.on('stop', () => {
+            this.stop();
+        });
+        this.on('snapshot', () => {
+            this.takeHeapSnapshot();
+        });
+        this.on('gc', () => {
+            this.runGarbageCollector();
+        });
+    }
+    async start() {
+        if (this.session) {
+            this.log.warn('Inspector session already active.');
+            return;
+        }
+        const { Session } = await import('node:inspector');
+        const { mkdirSync } = await import('node:fs');
+        this.log.debug(`Starting heap sampling...`);
+        mkdirSync('heap_profiles', { recursive: true });
+        mkdirSync('heap_snapshots', { recursive: true });
+        try {
+            this.session = new Session();
+            this.session.connect();
+            await new Promise((resolve, reject) => {
+                this.session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
+            });
+            this.log.debug(`Started heap sampling`);
+            const { getIntParameter } = await import('./commandLine.js');
+            const interval = getIntParameter('snapshotinterval');
+            if (interval && interval >= 30000) {
+                this.log.debug(`Started heap snapshot interval of ${CYAN}${interval}${db} ms`);
+                clearInterval(this.snapshotInterval);
+                this.snapshotInterval = setInterval(async () => {
+                    try {
+                        if (this.snapshotInProgress) {
+                            if (this.debug)
+                                this.log.debug(`Skip heap snapshot: previous snapshot still in progress`);
+                            return;
+                        }
+                        this.log.debug(`Run heap snapshot interval`);
+                        await this.takeHeapSnapshot();
+                    }
+                    catch (err) {
+                        this.log.error(`Error during scheduled heap snapshot: ${err instanceof Error ? err.message : err}`);
+                    }
+                }, interval).unref();
+            }
+        }
+        catch (err) {
+            this.log.error(`Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
+            this.session?.disconnect();
+            this.session = undefined;
+            return;
+        }
+    }
+    async stop() {
+        if (!this.session) {
+            this.log.warn('No active inspector session.');
+            return;
+        }
+        const { writeFileSync } = await import('node:fs');
+        const path = await import('node:path');
+        this.log.debug(`Stopping heap sampling...`);
+        if (this.snapshotInterval) {
+            this.log.debug(`Clearing heap snapshot interval...`);
+            clearInterval(this.snapshotInterval);
+            await this.takeHeapSnapshot();
+        }
+        try {
+            const result = await new Promise((resolve, reject) => {
+                this.session?.post('HeapProfiler.stopSampling', (err, result) => (err ? reject(err) : resolve(result)));
+            });
+            const profile = JSON.stringify(result.profile);
+            const safeTimestamp = new Date().toISOString().replace(/[<>:"/\\|?*]/g, '-');
+            const filename = path.join('heap_profiles', `${safeTimestamp}.heapprofile`);
+            writeFileSync(filename, profile);
+            this.log.debug(`Heap sampling profile saved to ${CYAN}${filename}${db}`);
+        }
+        catch (err) {
+            this.log.error(`Failed to stop heap sampling: ${err instanceof Error ? err.message : err}`);
+        }
+        finally {
+            this.session.disconnect();
+            this.session = undefined;
+            this.log.debug(`Stopped heap sampling`);
+        }
+    }
+    async takeHeapSnapshot() {
+        if (!this.session) {
+            this.log.warn('No active inspector session.');
+            return;
+        }
+        if (this.snapshotInProgress) {
+            if (this.debug)
+                this.log.debug('Heap snapshot already in progress, skipping.');
+            return;
+        }
+        this.snapshotInProgress = true;
+        const { createWriteStream } = await import('node:fs');
+        const path = await import('node:path');
+        const safeTimestamp = new Date().toISOString().replace(/[<>:"/\\|?*]/g, '-');
+        const filename = path.join('heap_snapshots', `${safeTimestamp}.heapsnapshot`);
+        this.runGarbageCollector('minor', 'async');
+        this.runGarbageCollector('major', 'async');
+        if (this.debug)
+            this.log.debug(`Taking heap snapshot to ${CYAN}${filename}${db}...`);
+        const stream = createWriteStream(filename, { flags: 'w' });
+        let streamErrored = false;
+        const onStreamError = (err) => {
+            streamErrored = true;
+            this.log.error(`Heap snapshot stream error: ${err instanceof Error ? err.message : err}`);
+        };
+        stream.once('error', onStreamError);
+        const chunksListener = (notification) => {
+            if (!stream.write(notification.params.chunk)) {
+            }
+        };
+        this.session.on('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+        try {
+            await new Promise((resolve) => {
+                this.session?.post('HeapProfiler.takeHeapSnapshot', (err) => {
+                    this.session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+                    const finalize = () => {
+                        if (!err && !streamErrored) {
+                            if (this.debug)
+                                this.log.debug(`Heap sampling snapshot saved to ${CYAN}${filename}${db}`);
+                            this.runGarbageCollector('minor', 'async');
+                            this.runGarbageCollector('major', 'async');
+                            this.emit('snapshot_done');
+                        }
+                        else if (err) {
+                            this.log.error(`Failed to take heap snapshot: ${err instanceof Error ? err.message : err}`);
+                            this.runGarbageCollector('minor', 'async');
+                            this.runGarbageCollector('major', 'async');
+                        }
+                        resolve();
+                    };
+                    try {
+                        stream.end(() => finalize());
+                    }
+                    catch (e) {
+                        this.log.error(`Error finalizing heap snapshot stream: ${e instanceof Error ? e.message : e}`);
+                        finalize();
+                    }
+                });
+            });
+        }
+        finally {
+            this.snapshotInProgress = false;
+        }
+    }
+    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}`);
+        }
+    }
+}

package/dist/utils/tracker.js

@@ -0,0 +1,229 @@
+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';
+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();
+        });
+    }
+    formatTimeStamp(timestamp) {
+        return `${new Date(timestamp).toLocaleString()}`;
+    }
+    formatOsUpTime(seconds) {
+        if (seconds >= 86400) {
+            const days = Math.floor(seconds / 86400);
+            return `${days} day${days !== 1 ? 's' : ''}`;
+        }
+        if (seconds >= 3600) {
+            const hours = Math.floor(seconds / 3600);
+            return `${hours} hour${hours !== 1 ? 's' : ''}`;
+        }
+        if (seconds >= 60) {
+            const minutes = Math.floor(seconds / 60);
+            return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
+        }
+        return `${seconds} second${seconds !== 1 ? 's' : ''}`;
+    }
+    formatPercent(percent) {
+        return `${percent.toFixed(2)} %`;
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const idx = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+        const value = bytes / Math.pow(1024, idx);
+        return `${value.toFixed(2)} ${units[idx]}`;
+    }
+    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: ${this.formatTimeStamp(entry.timestamp)} ` +
+                    `os ${CYAN}${BRIGHT}${this.formatPercent(entry.osCpu)}${RESET}${db} (${entry.peakOsCpu > prevEntry.peakOsCpu ? RED : ''}${this.formatPercent(entry.peakOsCpu)}${db}) ` +
+                    `process ${CYAN}${BRIGHT}${this.formatPercent(entry.processCpu)}${RESET}${db} (${entry.peakProcessCpu > prevEntry.peakProcessCpu ? RED : ''}${this.formatPercent(entry.peakProcessCpu)}${db}) ` +
+                    `rss: ${CYAN}${BRIGHT}${this.formatBytes(entry.rss)}${RESET}${db} (${entry.peakRss > prevEntry.peakRss ? RED : ''}${this.formatBytes(entry.peakRss)}${db}) ` +
+                    `heapUsed: ${CYAN}${BRIGHT}${this.formatBytes(entry.heapUsed)}${RESET}${db} (${entry.peakHeapUsed > prevEntry.peakHeapUsed ? RED : ''}${this.formatBytes(entry.peakHeapUsed)}${db}) ` +
+                    `heapTotal: ${CYAN}${BRIGHT}${this.formatBytes(entry.heapTotal)}${RESET}${db} (${entry.peakHeapTotal > prevEntry.peakHeapTotal ? RED : ''}${this.formatBytes(entry.peakHeapTotal)}${db}) ` +
+                    `external: ${CYAN}${BRIGHT}${this.formatBytes(entry.external)}${RESET}${db} (${entry.peakExternal > prevEntry.peakExternal ? RED : ''}${this.formatBytes(entry.peakExternal)}${db}) ` +
+                    `arrayBuffers: ${CYAN}${BRIGHT}${this.formatBytes(entry.arrayBuffers)}${RESET}${db} (${entry.peakArrayBuffers > prevEntry.peakArrayBuffers ? RED : ''}${this.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(`${this.formatTimeStamp(entry.timestamp)} ` +
+                    `${CYAN}${BRIGHT}${this.formatPercent(entry.osCpu).padStart(8)}${RESET} (${this.formatPercent(entry.peakOsCpu).padStart(8)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatPercent(entry.processCpu).padStart(8)}${RESET} (${this.formatPercent(entry.peakProcessCpu).padStart(8)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatBytes(entry.rss).padStart(9)}${RESET} (${this.formatBytes(entry.peakRss).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatBytes(entry.heapUsed).padStart(9)}${RESET} (${this.formatBytes(entry.peakHeapUsed).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatBytes(entry.heapTotal).padStart(9)}${RESET} (${this.formatBytes(entry.peakHeapTotal).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatBytes(entry.external).padStart(9)}${RESET} (${this.formatBytes(entry.peakExternal).padStart(9)}) ` +
+                    `${CYAN}${BRIGHT}${this.formatBytes(entry.arrayBuffers).padStart(9)}${RESET} (${this.formatBytes(entry.peakArrayBuffers).padStart(9)})`);
+            }
+        }
+        this.log.debug(`Tracker stopped`);
+    }
+}