@matterbridge/thread 3.10.14-dev-20261010-607ee18 → 3.10.14-dev-20261012-c6da540

package/dist/broadcastServer.d.ts

@@ -12,6 +12,7 @@ export declare class BroadcastServer extends EventEmitter<BroadcastServerEvents>
     private closed;
     private readonly debug;
     private readonly verbose;
+    private readonly diagnostic;
     constructor(name: WorkerSrcType, log: AnsiLogger, channel?: string);
     close(): void;
     private broadcastMessageHandler;

package/dist/broadcastServer.js

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { BroadcastChannel } from 'node:worker_threads';
-import { hasParameter } from '@matterbridge/utils/cli';
+import { hasAnyParameter } from '@matterbridge/utils/cli';
+import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
 import { logError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { CYAN, db, debugStringify, er } from 'node-ansi-logger';
@@ -11,8 +12,9 @@ export class BroadcastServer extends EventEmitter {
     channel;
     broadcastChannel;
     closed = false;
-    debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
-    verbose = hasParameter('verbose') || hasParameter('verbose-threads');
+    debug = hasAnyParameter('debug', 'verbose', 'debug-broadcast', 'verbose-broadcast');
+    verbose = hasAnyParameter('verbose', 'verbose-broadcast');
+    diagnostic = hasAnyParameter('diagnostic', 'diagnostic-broadcast');
     constructor(name, log, channel = 'broadcast-channel') {
         super();
         this.name = name;
@@ -158,6 +160,7 @@ export class BroadcastServer extends EventEmitter {
             return Promise.reject(new Error('Broadcast channel is closed'));
         }
         let timeoutId;
+        const start = performance.now();
         const requestMessage = {
             ...message,
             id: message.id ?? this.getUniqueId(),
@@ -173,6 +176,8 @@ export class BroadcastServer extends EventEmitter {
                     this.off('broadcast_message', responseHandler);
                     if (this.verbose)
                         this.log.debug(`Fetch response: ${debugStringify(msg)}`);
+                    if (this.diagnostic)
+                        writeDiagnostic(`Broadcast:${this.name}`, `fetch ${requestMessage.type} from ${requestMessage.src} to ${requestMessage.dst} took ${(performance.now() - start).toFixed(2)} ms`);
                     if ('error' in msg && typeof msg.error === 'string') {
                         reject(new Error(`Fetch received error response ${msg.error} to message type ${requestMessage.type} id ${requestMessage.id} from ${requestMessage.src} to ${requestMessage.dst}`));
                     }

package/dist/threadsManager.js

@@ -27,8 +27,8 @@ export class ThreadsManager {
         { name: 'SpawnCommand', path: 'workerSpawnCommand.js', type: 'worker' },
         { name: 'ArchiveCommand', path: 'workerArchiveCommand.js', type: 'worker' },
         { name: 'DockerVersion', path: 'workerDockerVersion.js', type: 'worker' },
-        { name: 'Backend', path: 'threadBackend.js', type: 'thread' },
-        { name: 'RootNode', path: 'threadRootNode.js', type: 'thread', multiple: true },
+        { name: 'Backend', path: 'threadBackend.js', type: 'thread', startup: true, shutdown: true },
+        { name: 'RootNode', path: 'threadRootNode.js', type: 'thread', multiple: true, startup: true, shutdown: true },
         { name: 'Tracker', path: 'threadTracker.js', type: 'thread', multiple: true, startup: true, shutdown: true },
     ];
     terminateWorkers = new Set();
@@ -62,7 +62,7 @@ export class ThreadsManager {
             this.log.notice(`ThreadsManager destroyed. Broadcast server closed.`);
     }
     msgHandler(msg) {
-        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'manager')) {
+        if (this.server.isWorkerRequest(msg)) {
             if (this.verbose)
                 this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
@@ -141,12 +141,13 @@ export class ThreadsManager {
         this.terminateExitedWorkers();
         for (const thread of this.threads) {
             for (const info of [thread, ...(thread.instances ?? [])]) {
-                if (info.worker && Date.now() - (info.lastSeen ?? 0) > this.intervalMs) {
+                if (info.worker) {
                     const msg = { type: 'ping', threadId: info.worker.threadId, threadName: thread.name };
                     info.worker.postMessage(msg);
+                    this.log.debug(`Sent ping to thread ${thread.name} threadId ${info.worker.threadId}`);
                 }
                 if (info.worker && Date.now() - (info.lastSeen ?? 0) > this.intervalMs * 2) {
-                    this.log.warn(`Thread ${CYAN}${thread.name}${db} has not been seen for more than ${this.intervalMs * 2} ms. It may be unresponsive.`);
+                    this.log.warn(`Thread ${CYAN}${thread.name}${wr} has not been seen for more than ${this.intervalMs * 2} ms. It may be unresponsive.`);
                 }
             }
         }
@@ -205,7 +206,10 @@ export class ThreadsManager {
                 this.log.debug(`Thread ${threadInfo.name} sent a message at ${new Date(now).toISOString()}: ${debugStringify(message)}`);
             if (message.type === 'init') {
                 threadInfo.runCount = (threadInfo.runCount ?? 0) + 1;
-                this.log.debug(`Thread ${threadInfo.name} is online started at ${new Date(now).toISOString()} with thread id ${worker.threadId}`);
+                this.log.debug(`Thread ${threadInfo.name} is initialized at ${new Date(now).toISOString()} with thread id ${worker.threadId}`);
+            }
+            else if (message.type === 'ready') {
+                this.log.debug(`Thread ${threadInfo.name} is ready at ${new Date(now).toISOString()} with thread id ${worker.threadId}`);
                 if (threadInfo.startup) {
                     const startupMessage = { type: 'startup', threadName: threadInfo.name, threadId: worker.threadId };
                     worker.postMessage(startupMessage);

package/dist/threadsWrapper.d.ts

@@ -10,6 +10,8 @@ export interface ThreadsWrapperEvents {
 export declare class ThreadsWrapper extends EventEmitter<ThreadsWrapperEvents> {
     name: ThreadNames;
     entrypoint: (worker: ThreadsWrapper) => Promise<boolean>;
+    startup?: ((worker: ThreadsWrapper) => Promise<void>) | undefined;
+    shutdown?: ((worker: ThreadsWrapper) => Promise<void>) | undefined;
     debug: boolean;
     verbose: boolean;
     useTracker: boolean;
@@ -20,7 +22,7 @@ export declare class ThreadsWrapper extends EventEmitter<ThreadsWrapperEvents> {
     private destroyed;
     private readonly boundUnhandledRejectionHandler;
     private readonly boundUncaughtExceptionHandler;
-    constructor(name: ThreadNames, entrypoint: (worker: ThreadsWrapper) => Promise<boolean>);
+    constructor(name: ThreadNames, entrypoint: (worker: ThreadsWrapper) => Promise<boolean>, startup?: ((worker: ThreadsWrapper) => Promise<void>) | undefined, shutdown?: ((worker: ThreadsWrapper) => Promise<void>) | undefined);
     destroy(success: boolean): void;
     private handleUnhandledRejection;
     private handleUncaughtException;

package/dist/threadsWrapper.js

@@ -11,6 +11,8 @@ logModuleLoaded('ThreadsWrapper');
 export class ThreadsWrapper extends EventEmitter {
     name;
     entrypoint;
+    startup;
+    shutdown;
     debug = hasAnyParameter('debug', 'verbose', 'debug-threads', 'verbose-threads');
     verbose = hasAnyParameter('verbose', 'verbose-threads');
     useTracker = hasAnyParameter('tracker', 'tracker-threads');
@@ -25,10 +27,12 @@ export class ThreadsWrapper extends EventEmitter {
     boundUncaughtExceptionHandler = (error) => {
         this.handleUncaughtException(error);
     };
-    constructor(name, entrypoint) {
+    constructor(name, entrypoint, startup, shutdown) {
         super();
         this.name = name;
         this.entrypoint = entrypoint;
+        this.startup = startup;
+        this.shutdown = shutdown;
         if (this.workerData) {
             this.debug = this.workerData.debug ?? this.debug;
             this.verbose = this.workerData.verbose ?? this.verbose;
@@ -43,7 +47,7 @@ export class ThreadsWrapper extends EventEmitter {
         if (this.useTracker) {
             void import('@matterbridge/utils/tracker')
                 .then(({ Tracker }) => {
-                this.tracker = new Tracker(`Thread${this.name}`, this.debug || this.useTracker, this.verbose, this.useTracker);
+                this.tracker = new Tracker(`Thread${this.name}`, this.debug, this.verbose, this.useTracker);
                 this.tracker.start();
                 return;
             })
@@ -68,10 +72,32 @@ export class ThreadsWrapper extends EventEmitter {
                         this.parentLog(this.name, "debug", `Worker ${this.name}:${threadId} sent pong message type to parent: ${debugStringify(message)}`);
                         break;
                     case 'startup':
-                        setImmediate(() => this.emit('startup'));
+                        setImmediate(() => {
+                            void (async () => {
+                                try {
+                                    if (startup)
+                                        await startup(this);
+                                }
+                                catch (err) {
+                                    inspectError(this.log, `Worker ${this.name} startup failed`, err);
+                                }
+                            })();
+                            this.emit('startup');
+                        });
                         break;
                     case 'shutdown':
-                        setImmediate(() => this.emit('shutdown'));
+                        setImmediate(() => {
+                            void (async () => {
+                                try {
+                                    if (shutdown)
+                                        await shutdown(this);
+                                }
+                                catch (err) {
+                                    inspectError(this.log, `Worker ${this.name} shutdown failed`, err);
+                                }
+                            })();
+                            this.emit('shutdown');
+                        });
                         break;
                     default:
                         this.parentLog(this.name, "warn", `Worker ${this.name}:${threadId} received unknown message type from parent: ${debugStringify(message)}`);
@@ -95,6 +121,7 @@ export class ThreadsWrapper extends EventEmitter {
                     let success = false;
                     try {
                         success = await entrypoint(this);
+                        this.parentPost({ type: 'ready', threadId, threadName: this.name, memoryUsage: process.memoryUsage(), success: true });
                     }
                     catch (err) {
                         inspectError(this.log, `Worker ${this.name} entrypoint failed`, err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.10.14-dev-20261010-607ee18",
+  "version": "3.10.14-dev-20261012-c6da540",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -80,8 +80,8 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/types": "3.10.14-dev-20261010-607ee18",
-    "@matterbridge/utils": "3.10.14-dev-20261010-607ee18",
+    "@matterbridge/types": "3.10.14-dev-20261012-c6da540",
+    "@matterbridge/utils": "3.10.14-dev-20261012-c6da540",
     "@zip.js/zip.js": "2.23.0",
     "node-ansi-logger": "3.3.1"
   }