matterbridge 3.3.1-dev-20251007-4e5eaac → 3.3.1-dev-20251009-edb969d

package/CHANGELOG.md

@@ -36,7 +36,13 @@ Advantages:
 - [network]: Added getInterfaceName() function.
 - [network]: Optimized code.
 - [matterbridge]: Added SharedMatterbridge readonly type.
-- [thread]: Add BroadcastServer to frontend plugins and devices.
+- [thread]: Added BroadcastServer to frontend, plugins and devices.
+- [cli]: Added cpu and memory history to cli.
+- [cli]: Added cpu and memory peaks history to cli.
+- [cli]: Added host cpu and process cpu to cli.
+- [frontend]: Added process cpu to SystemInformation.
+- [frontend]: Added under 'View' menu the item 'Matterbridge diagnostic log'. It shows the complete matter server nodes.
+- [frontend]: Added under 'View' menu the item 'Matterbridge system history'. It shows the graph page of the last 6h of host cpu, process cpu and memory usage (rss, heap used, heap total with peaks).
 
 ### Changed
 
@@ -46,6 +52,12 @@ Advantages:
 - [frontend]: Refactored InstallProgressDialog.
 - [spawn]: Refactored spawnCommand for compatibility with InstallProgressDialog.
 - [matter.js]: Bumped `matter.js` to 0.15.5. Thanks matter.js!
+- [backend]: Optimized imports.
+- [cli]: Bumped `cli` version to 2.1.0.
+
+### Fixed
+
+- [frontend]: Fixed matter log on file not setting correctly.
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">

package/dist/broadcastServer.js

@@ -1,3 +1,5 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mBroadcastServer loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 import { BroadcastChannel } from 'node:worker_threads';
 import { debugStringify } from 'node-ansi-logger';

package/dist/cli.js

@@ -1,17 +1,30 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mCLI loaded.\u001B[40;0m');
 import os from 'node:os';
 import { inspect } from 'node:util';
-import { AnsiLogger, BRIGHT, CYAN, db, YELLOW } from 'node-ansi-logger';
-import { getIntParameter, hasParameter } from './utils/export.js';
+import { AnsiLogger, BRIGHT, CYAN, db, RED, YELLOW } from 'node-ansi-logger';
+import { cliEmitter, setLastCpuUsage, setLastProcessCpuUsage } from './cliEmitter.js';
+import { history, historyIndex, historySize, setHistoryIndex } from './cliHistory.js';
+import { getIntParameter, hasParameter } from './utils/commandLine.js';
 import { Matterbridge } from './matterbridge.js';
-import { cliEmitter, lastCpuUsage, setLastCpuUsage } from './cliEmitter.js';
 export let instance;
 let session;
 let snapshotInterval;
+const trace = hasParameter('trace');
 let memoryCheckInterval;
+const memoryCheckIntervalMs = getIntParameter('memoryinterval') ?? 10 * 1000;
+let memoryPeakResetTimeout;
 let prevCpus;
+let prevProcessCpu;
 let peakCpu = 0;
+let peakProcessCpu = 0;
 let peakRss = 0;
+let peakHeapUsed = 0;
+let peakHeapTotal = 0;
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+const formatCpuUsage = (percent) => {
+    return `${percent.toFixed(2).padStart(5, ' ')} %`;
+};
 const formatMemoryUsage = (bytes) => {
     if (bytes >= 1024 ** 3) {
         return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
@@ -41,6 +54,7 @@ const formatOsUpTime = (seconds) => {
 async function startCpuMemoryCheck() {
     log.debug(`Cpu memory check started`);
     prevCpus = os.cpus();
+    prevProcessCpu = process.cpuUsage();
     clearInterval(memoryCheckInterval);
     const interval = () => {
         const systemUptime = formatOsUpTime(Math.floor(os.uptime()));
@@ -54,11 +68,23 @@ async function startCpuMemoryCheck() {
         const heapUsed = formatMemoryUsage(memoryUsageRaw.heapUsed);
         const external = formatMemoryUsage(memoryUsageRaw.external);
         const arrayBuffers = formatMemoryUsage(memoryUsageRaw.arrayBuffers);
-        if (memoryUsageRaw.rss > peakRss)
+        if (memoryUsageRaw.rss > peakRss) {
+            if (peakRss && trace)
+                log.debug(`****${RED}${BRIGHT}Rss peak detected.${db} Peak rss from ${CYAN}${formatMemoryUsage(peakRss)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.rss)}${db}`);
             peakRss = memoryUsageRaw.rss;
+        }
+        if (memoryUsageRaw.heapUsed > peakHeapUsed) {
+            if (peakHeapUsed && trace)
+                log.debug(`****${RED}${BRIGHT}HeapUsed peak detected.${db} Peak heapUsed from ${CYAN}${formatMemoryUsage(peakHeapUsed)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.heapUsed)}${db}`);
+            peakHeapUsed = memoryUsageRaw.heapUsed;
+        }
+        if (memoryUsageRaw.heapTotal > peakHeapTotal) {
+            if (peakHeapTotal && trace)
+                log.debug(`****${RED}${BRIGHT}HeapTotal peak detected.${db} Peak heapTotal from ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.heapTotal)}${db}`);
+            peakHeapTotal = memoryUsageRaw.heapTotal;
+        }
         cliEmitter.emit('memory', totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
         const currCpus = os.cpus();
-        let cpuUsageLog;
         if (currCpus.length !== prevCpus.length) {
             prevCpus = currCpus;
             log.debug(`Cpu check length failed, resetting previous cpus`);
@@ -74,27 +100,64 @@ async function startCpuMemoryCheck() {
         });
         const cpuUsage = 100 - (totalIdle / totalTick) * 100;
         if (totalTick === 0 || isNaN(cpuUsage) || !isFinite(cpuUsage) || cpuUsage <= 0) {
-            if (lastCpuUsage != 0)
-                log.debug(`Cpu check failed, using previous cpus`);
-            cpuUsageLog = lastCpuUsage.toFixed(2);
+            log.debug(`Cpu check failed, using previous cpus`);
         }
         else {
-            cpuUsageLog = cpuUsage.toFixed(2);
             setLastCpuUsage(cpuUsage);
-            if (lastCpuUsage > peakCpu)
-                peakCpu = lastCpuUsage;
-            cliEmitter.emit('cpu', lastCpuUsage);
+            if (cpuUsage > peakCpu) {
+                peakCpu = cpuUsage;
+                if (peakCpu && trace)
+                    log.debug(`****${RED}${BRIGHT}Cpu peak detected.${db} Peak cpu from ${CYAN}${formatCpuUsage(peakCpu)}${db} to ${CYAN}${formatCpuUsage(cpuUsage)}${db}`);
+            }
         }
         prevCpus = currCpus;
-        log.debug(`***${YELLOW}${BRIGHT}Cpu usage:${db} ${CYAN}${cpuUsageLog.padStart(6, ' ')} %${db} ${YELLOW}${BRIGHT}Memory usage:${db} rss ${CYAN}${rss}${db} heapTotal ${CYAN}${heapTotal}${db} heapUsed ${CYAN}${heapUsed}${db} external ${external} arrayBuffers ${arrayBuffers}`);
+        const diff = process.cpuUsage(prevProcessCpu);
+        const userMs = diff.user / 1000;
+        const systemMs = diff.system / 1000;
+        const totalMs = userMs + systemMs;
+        const processCpuUsage = Number(((totalMs / memoryCheckIntervalMs) * 100).toFixed(2));
+        if (processCpuUsage > peakProcessCpu) {
+            peakProcessCpu = processCpuUsage;
+            if (peakProcessCpu && trace)
+                log.debug(`****${RED}${BRIGHT}Process cpu peak detected.${db} Peak process cpu from ${CYAN}${formatCpuUsage(peakProcessCpu)}${db} to ${CYAN}${formatCpuUsage(processCpuUsage)}${db}`);
+        }
+        prevProcessCpu = process.cpuUsage();
+        setLastProcessCpuUsage(processCpuUsage);
+        cliEmitter.emit('cpu', cpuUsage, processCpuUsage);
+        const entry = history[historyIndex];
+        entry.cpu = cpuUsage;
+        entry.peakCpu = peakCpu;
+        entry.processCpu = processCpuUsage;
+        entry.peakProcessCpu = peakProcessCpu;
+        entry.rss = memoryUsageRaw.rss;
+        entry.peakRss = peakRss;
+        entry.heapUsed = memoryUsageRaw.heapUsed;
+        entry.peakHeapUsed = peakHeapUsed;
+        entry.heapTotal = memoryUsageRaw.heapTotal;
+        entry.peakHeapTotal = peakHeapTotal;
+        entry.timestamp = Date.now();
+        setHistoryIndex((historyIndex + 1) % historySize);
+        if (trace)
+            log.debug(`***${YELLOW}${BRIGHT}Host cpu:${db} ${CYAN}${formatCpuUsage(cpuUsage)}${db} (peak ${formatCpuUsage(peakCpu)}) ${YELLOW}${BRIGHT}Process cpu:${db} ${CYAN}${formatCpuUsage(processCpuUsage)}${db} (peak ${formatCpuUsage(peakProcessCpu)}) ${YELLOW}${BRIGHT}Process memory:${db} rss ${CYAN}${rss}${db} (peak ${formatMemoryUsage(peakRss)}) heapUsed ${CYAN}${heapUsed}${db} (peak ${formatMemoryUsage(peakHeapUsed)}) heapTotal ${CYAN}${heapTotal}${db} (peak ${formatMemoryUsage(peakHeapTotal)}) external ${external} arrayBuffers ${arrayBuffers}`);
     };
-    interval();
     clearInterval(memoryCheckInterval);
-    memoryCheckInterval = setInterval(interval, getIntParameter('memoryinterval') ?? 10 * 1000).unref();
+    memoryCheckInterval = setInterval(interval, memoryCheckIntervalMs).unref();
+    clearTimeout(memoryPeakResetTimeout);
+    memoryPeakResetTimeout = setTimeout(() => {
+        log.debug(`****${RED}${BRIGHT}Cpu and memory peaks reset after first 5 minutes.${db}`);
+        peakCpu = 0;
+        peakProcessCpu = 0;
+        peakRss = 0;
+        peakHeapUsed = 0;
+        peakHeapTotal = 0;
+    }, 5 * 60 * 1000).unref();
 }
 async function stopCpuMemoryCheck() {
-    log.debug(`***Cpu memory check stopped. Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}.`);
+    if (trace) {
+        log.debug(`***Cpu memory check stopped. Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}. Peak heapUsed: ${CYAN}${formatMemoryUsage(peakHeapUsed)}${db}. Peak heapTotal: ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db}`);
+    }
     clearInterval(memoryCheckInterval);
+    clearTimeout(memoryPeakResetTimeout);
 }
 async function startInspector() {
     const { Session } = await import('node:inspector');

package/dist/cliEmitter.js

@@ -1,6 +1,12 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mCli emitter loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 export const cliEmitter = new EventEmitter();
 export let lastCpuUsage = 0;
+export let lastProcessCpuUsage = 0;
 export function setLastCpuUsage(val) {
     lastCpuUsage = val;
 }
+export function setLastProcessCpuUsage(val) {
+    lastProcessCpuUsage = val;
+}