@resolveio/server-lib 20.14.22 → 20.14.24

package/managers/worker-dispatcher.manager.d.ts

@@ -31,9 +31,14 @@ export declare class WorkerDispatcherManager {
     private _taskTimings;
     private MAX_CONCURRENCY;
     private WORKER_TASK_LOG_THRESHOLD_MS;
+    private WORKER_PUBLICATION_SLOW_MS;
+    private _workerTaskDebug;
     constructor();
     static create(websocketManager: WebSocketManager, methodManager: MethodManager): WorkerDispatcherManager;
     initialize(websocketManager: WebSocketManager, methodManager: MethodManager): void;
+    private parseDebugFlag;
+    private summarizePublicationValue;
+    private getPublicationLogInfo;
     isSafeShutdown(): boolean;
     addWorker(ws: WebSocket.WebSocket): void;
     disconnectWorker(workerId: string): void;

package/managers/worker-dispatcher.manager.js

@@ -35,6 +35,8 @@ var WorkerDispatcherManager = /** @class */ (function () {
         this._taskTimings = new Map();
         this.MAX_CONCURRENCY = 10;
         this.WORKER_TASK_LOG_THRESHOLD_MS = 200;
+        this.WORKER_PUBLICATION_SLOW_MS = 20000;
+        this._workerTaskDebug = false;
     }
     WorkerDispatcherManager.create = function (websocketManager, methodManager) {
         var workerDispatcherManager = new WorkerDispatcherManager();
@@ -42,8 +44,62 @@ var WorkerDispatcherManager = /** @class */ (function () {
         return workerDispatcherManager;
     };
     WorkerDispatcherManager.prototype.initialize = function (websocketManager, methodManager) {
+        var _a, _b;
         this._websocketManager = websocketManager;
         this._methodManager = methodManager;
+        this._workerTaskDebug = this.parseDebugFlag((_a = process.env.WORKER_TASK_DEBUG) !== null && _a !== void 0 ? _a : process.env.WORKER_DISPATCH_DEBUG);
+        var slowPublicationMs = parseInt((_b = process.env.WORKER_PUBLICATION_SLOW_MS) !== null && _b !== void 0 ? _b : '', 10);
+        if (!Number.isNaN(slowPublicationMs) && slowPublicationMs > 0) {
+            this.WORKER_PUBLICATION_SLOW_MS = slowPublicationMs;
+        }
+    };
+    WorkerDispatcherManager.prototype.parseDebugFlag = function (value) {
+        if (value === true) {
+            return true;
+        }
+        if (value === false || value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'number') {
+            return value === 1;
+        }
+        if (typeof value === 'string') {
+            var normalized = value.trim().toLowerCase();
+            return ['1', 'true', 'yes', 'y', 'on'].includes(normalized);
+        }
+        return false;
+    };
+    WorkerDispatcherManager.prototype.summarizePublicationValue = function (value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        var valueType = typeof value;
+        if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return "[Array(".concat(value.length, ")]");
+        }
+        if (valueType === 'object') {
+            return "[Object keys=".concat(Object.keys(value).length, "]");
+        }
+        return "[".concat(valueType, "]");
+    };
+    WorkerDispatcherManager.prototype.getPublicationLogInfo = function (method, params) {
+        var _this = this;
+        if (method !== 'runPublication' || !Array.isArray(params)) {
+            return null;
+        }
+        var publication = typeof params[0] === 'string' ? params[0] : null;
+        var subscriptionData = Array.isArray(params[1]) ? params[1] : [];
+        var userId = typeof params[2] === 'string' ? params[2] : null;
+        var subscriptionDataPreview = subscriptionData.slice(0, 3).map(function (item) { return _this.summarizePublicationValue(item); });
+        return {
+            publication: publication,
+            subscriptionDataCount: subscriptionData.length,
+            subscriptionDataPreview: subscriptionDataPreview,
+            userId: userId
+        };
     };
     WorkerDispatcherManager.prototype.isSafeShutdown = function () {
         return !this._taskQueue.length && !this._pendingTasks.size;
@@ -127,11 +183,27 @@ var WorkerDispatcherManager = /** @class */ (function () {
             queuedAt: queuedAt,
             method: method,
             messageId: messageId,
-            userContext: userContext
+            userContext: userContext,
+            params: params
         });
         if (userContext && userContext.id_ws) {
             this._clientRequests[taskId] = userContext.id_ws;
         }
+        if (this.shouldDebug()) {
+            var publicationInfo = this.getPublicationLogInfo(method, params);
+            var logPayload = {
+                taskId: taskId,
+                method: method,
+                messageId: messageId,
+                priority: method === 'runPublication' ? 'publication' : 'method',
+                queueDepth: this._taskQueue.length,
+                userContext: userContext
+            };
+            if (publicationInfo) {
+                Object.assign(logPayload, publicationInfo);
+            }
+            this.logWorkerEvent('workerTaskQueued', logPayload);
+        }
         this.dispatchQueue();
     };
     /**
@@ -162,7 +234,8 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 queuedAt: queuedAt,
                 method: method,
                 messageId: 0,
-                userContext: { user: 'Internal System' }
+                userContext: { user: 'Internal System' },
+                params: params
             });
             _this._pendingTasks.set(taskId, {
                 timeout: null,
@@ -171,6 +244,21 @@ var WorkerDispatcherManager = /** @class */ (function () {
             if (_this._methodManager.getEnableDebug()) {
                 console.log(new Date(), 'Send Internal Promise', _this._taskQueue);
             }
+            if (_this.shouldDebug()) {
+                var publicationInfo = _this.getPublicationLogInfo(method, params);
+                var logPayload = {
+                    taskId: taskId,
+                    method: method,
+                    messageId: 0,
+                    priority: method === 'runPublication' ? 'publication' : 'method',
+                    queueDepth: _this._taskQueue.length,
+                    userContext: { user: 'Internal System' }
+                };
+                if (publicationInfo) {
+                    Object.assign(logPayload, publicationInfo);
+                }
+                _this.logWorkerEvent('workerTaskQueued', logPayload);
+            }
             _this.dispatchQueue();
         });
     };
@@ -202,7 +290,8 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 queuedAt: queuedAt,
                 method: method,
                 messageId: 0,
-                userContext: { user: 'Internal System' }
+                userContext: { user: 'Internal System' },
+                params: params
             });
             _this._pendingTasks.set(taskId, {
                 timeout: null,
@@ -212,6 +301,21 @@ var WorkerDispatcherManager = /** @class */ (function () {
             if (_this._methodManager.getEnableDebug()) {
                 console.log(new Date(), 'Send Internal Raw Promise', _this._taskQueue);
             }
+            if (_this.shouldDebug()) {
+                var publicationInfo = _this.getPublicationLogInfo(method, params);
+                var logPayload = {
+                    taskId: taskId,
+                    method: method,
+                    messageId: 0,
+                    priority: method === 'runPublication' ? 'publication' : 'method',
+                    queueDepth: _this._taskQueue.length,
+                    userContext: { user: 'Internal System' }
+                };
+                if (publicationInfo) {
+                    Object.assign(logPayload, publicationInfo);
+                }
+                _this.logWorkerEvent('workerTaskQueued', logPayload);
+            }
             _this.dispatchQueue();
         });
     };
@@ -240,11 +344,27 @@ var WorkerDispatcherManager = /** @class */ (function () {
             queuedAt: queuedAt,
             method: method,
             messageId: 0,
-            userContext: { user: 'Internal System' }
+            userContext: { user: 'Internal System' },
+            params: params
         });
         if (this._methodManager.getEnableDebug()) {
             console.log(new Date(), 'Send Internal Task', this._taskQueue);
         }
+        if (this.shouldDebug()) {
+            var publicationInfo = this.getPublicationLogInfo(method, params);
+            var logPayload = {
+                taskId: taskId,
+                method: method,
+                messageId: 0,
+                priority: method === 'runPublication' ? 'publication' : 'method',
+                queueDepth: this._taskQueue.length,
+                userContext: { user: 'Internal System' }
+            };
+            if (publicationInfo) {
+                Object.assign(logPayload, publicationInfo);
+            }
+            this.logWorkerEvent('workerTaskQueued', logPayload);
+        }
         this.dispatchQueue();
     };
     /**
@@ -257,14 +377,32 @@ var WorkerDispatcherManager = /** @class */ (function () {
         }
         while (this._taskQueue.length > 0) {
             var assigned = false;
-            for (var i = 0; i < this._taskQueue.length; i++) {
-                var task = this._taskQueue[i];
-                var targetWorker = this.findWorkerForTask(task);
-                if (targetWorker) {
-                    this._taskQueue.splice(i, 1);
-                    this.assignTaskToWorker(targetWorker, task);
-                    assigned = true;
-                    break;
+            var hasPublicationTask = this._taskQueue.some(function (task) { return task.method === 'runPublication'; });
+            if (hasPublicationTask) {
+                for (var i = 0; i < this._taskQueue.length; i++) {
+                    var task = this._taskQueue[i];
+                    if (task.method !== 'runPublication') {
+                        continue;
+                    }
+                    var targetWorker = this.findWorkerForTask(task);
+                    if (targetWorker) {
+                        this._taskQueue.splice(i, 1);
+                        this.assignTaskToWorker(targetWorker, task);
+                        assigned = true;
+                        break;
+                    }
+                }
+            }
+            if (!assigned) {
+                for (var i = 0; i < this._taskQueue.length; i++) {
+                    var task = this._taskQueue[i];
+                    var targetWorker = this.findWorkerForTask(task);
+                    if (targetWorker) {
+                        this._taskQueue.splice(i, 1);
+                        this.assignTaskToWorker(targetWorker, task);
+                        assigned = true;
+                        break;
+                    }
                 }
             }
             if (!assigned) {
@@ -381,6 +519,9 @@ var WorkerDispatcherManager = /** @class */ (function () {
         timing.method = task.method;
         timing.messageId = task.messageId;
         timing.userContext = task.userContext;
+        if (!timing.params) {
+            timing.params = task.params;
+        }
         this._taskTimings.set(task.taskId, timing);
         worker.activeTasks.push({
             taskId: task.taskId,
@@ -401,6 +542,25 @@ var WorkerDispatcherManager = /** @class */ (function () {
             queuedAt: timing.queuedAt,
             dispatchedAt: dispatchedAt
         };
+        if (this.shouldDebug()) {
+            var publicationInfo = this.getPublicationLogInfo(task.method, task.params);
+            var logPayload = {
+                taskId: task.taskId,
+                method: task.method,
+                messageId: task.messageId,
+                priority: task.method === 'runPublication' ? 'publication' : 'method',
+                worker: {
+                    id: worker.id,
+                    index: worker.workerIndex,
+                    instance: worker.workerInstance
+                },
+                queueDepth: this._taskQueue.length
+            };
+            if (publicationInfo) {
+                Object.assign(logPayload, publicationInfo);
+            }
+            this.logWorkerEvent('workerTaskAssigned', logPayload);
+        }
         var timeoutHandle = setTimeout(function () {
             var pending = _this._pendingTasks.get(task.taskId);
             var timeoutAt = Date.now();
@@ -413,7 +573,8 @@ var WorkerDispatcherManager = /** @class */ (function () {
                 }
                 _this._pendingTasks.delete(task.taskId);
             }
-            _this.logWorkerEvent('workerTaskTimeout', {
+            var publicationInfo = _this.getPublicationLogInfo(task.method, task.params);
+            var logPayload = {
                 taskId: task.taskId,
                 method: task.method,
                 messageId: task.messageId,
@@ -426,7 +587,11 @@ var WorkerDispatcherManager = /** @class */ (function () {
                     instance: worker.workerInstance
                 },
                 workers: _this._workers.map(function (a) { return a.activeTasks; })
-            });
+            };
+            if (publicationInfo) {
+                Object.assign(logPayload, publicationInfo);
+            }
+            _this.logWorkerEvent('workerTaskTimeout', logPayload);
             worker.activeTasks = worker.activeTasks.filter(function (a) { return a.taskId !== task.taskId; });
             _this._taskTimings.delete(task.taskId);
             if (task.userContext && task.userContext.id_ws) {
@@ -516,7 +681,14 @@ var WorkerDispatcherManager = /** @class */ (function () {
         }
     };
     WorkerDispatcherManager.prototype.shouldDebug = function () {
-        return this._methodManager.getEnableDebug() || process.env.WORKER_DISPATCH_DEBUG === 'true';
+        var _a;
+        if (this._methodManager.getEnableDebug()) {
+            return true;
+        }
+        if (this._workerTaskDebug) {
+            return true;
+        }
+        return this.parseDebugFlag((_a = process.env.WORKER_TASK_DEBUG) !== null && _a !== void 0 ? _a : process.env.WORKER_DISPATCH_DEBUG);
     };
     WorkerDispatcherManager.prototype.logWorkerEvent = function (event, details) {
         console.log(this.safeStringify(__assign({ ts: new Date().toISOString(), event: event }, details)));
@@ -558,6 +730,7 @@ var WorkerDispatcherManager = /** @class */ (function () {
      * Handle messages coming back from a worker (like 'taskComplete').
      */
     WorkerDispatcherManager.prototype.handleWorkerMessage = function (workerId, rawMessage) {
+        var _a;
         var data;
         try {
             if (typeof rawMessage === 'string') {
@@ -614,10 +787,39 @@ var WorkerDispatcherManager = /** @class */ (function () {
             }
             worker.activeTasks = worker.activeTasks.filter(function (a) { return a.taskId !== taskId_1; });
             this._taskTimings.delete(taskId_1);
-            if (error || (dispatchToCompleteMs !== null && dispatchToCompleteMs >= this.WORKER_TASK_LOG_THRESHOLD_MS)) {
-                this.logWorkerEvent('workerTaskComplete', {
+            var method = (_a = pendingTask === null || pendingTask === void 0 ? void 0 : pendingTask.method) !== null && _a !== void 0 ? _a : timing === null || timing === void 0 ? void 0 : timing.method;
+            var params = timing === null || timing === void 0 ? void 0 : timing.params;
+            var publicationInfo = this.getPublicationLogInfo(method, params);
+            var isSlowPublication = !!publicationInfo && totalMs !== null && totalMs >= this.WORKER_PUBLICATION_SLOW_MS;
+            var shouldLogComplete = !!error || (dispatchToCompleteMs !== null && dispatchToCompleteMs >= this.WORKER_TASK_LOG_THRESHOLD_MS);
+            if (isSlowPublication) {
+                var logPayload = {
                     taskId: taskId_1,
-                    method: pendingTask === null || pendingTask === void 0 ? void 0 : pendingTask.method,
+                    method: method,
+                    messageId: messageId,
+                    error: error,
+                    dispatchToCompleteMs: dispatchToCompleteMs,
+                    queueWaitMs: queueWaitMs,
+                    totalMs: totalMs,
+                    packedBytes: packedBytes,
+                    userContext: timing === null || timing === void 0 ? void 0 : timing.userContext,
+                    worker: {
+                        id: worker.id,
+                        index: worker.workerIndex,
+                        instance: worker.workerInstance
+                    },
+                    queue: this.getQueueSnapshot(),
+                    slowThresholdMs: this.WORKER_PUBLICATION_SLOW_MS
+                };
+                if (publicationInfo) {
+                    Object.assign(logPayload, publicationInfo);
+                }
+                this.logWorkerEvent('workerPublicationSlow', logPayload);
+            }
+            else if (shouldLogComplete) {
+                var logPayload = {
+                    taskId: taskId_1,
+                    method: method,
                     messageId: messageId,
                     error: error,
                     dispatchToCompleteMs: dispatchToCompleteMs,
@@ -631,7 +833,34 @@ var WorkerDispatcherManager = /** @class */ (function () {
                         instance: worker.workerInstance
                     },
                     queue: this.getQueueSnapshot()
-                });
+                };
+                if (publicationInfo) {
+                    Object.assign(logPayload, publicationInfo);
+                }
+                this.logWorkerEvent('workerTaskComplete', logPayload);
+            }
+            else if (this.shouldDebug()) {
+                var logPayload = {
+                    taskId: taskId_1,
+                    method: method,
+                    messageId: messageId,
+                    error: error,
+                    dispatchToCompleteMs: dispatchToCompleteMs,
+                    queueWaitMs: queueWaitMs,
+                    totalMs: totalMs,
+                    packedBytes: packedBytes,
+                    userContext: timing === null || timing === void 0 ? void 0 : timing.userContext,
+                    worker: {
+                        id: worker.id,
+                        index: worker.workerIndex,
+                        instance: worker.workerInstance
+                    },
+                    queue: this.getQueueSnapshot()
+                };
+                if (publicationInfo) {
+                    Object.assign(logPayload, publicationInfo);
+                }
+                this.logWorkerEvent('workerTaskCompleteDebug', logPayload);
             }
             if (pendingTask) {
                 if (pendingTask.promise) {