@resolveio/server-lib 20.14.14 → 20.14.15

package/managers/subscription.manager.d.ts

@@ -48,6 +48,7 @@ export declare class SubscriptionManager {
     private _latencyFlushPending;
     private readonly LATENCY_UPDATE_INTERVAL;
     private readonly LATENCY_UPDATE_THRESHOLD_MS;
+    private readonly LATENCY_DEBUG_THRESHOLD_MS;
     private _invalidationDebounceTimers;
     private _invalidationPendingTimestamps;
     private _pendingInvalidations;

package/managers/subscription.manager.js

@@ -159,6 +159,7 @@ var SubscriptionManager = /** @class */ (function () {
         this.LATENCY_UPDATE_INTERVAL = 60000;
         // Minimum time difference between two latency updates for the same user
         this.LATENCY_UPDATE_THRESHOLD_MS = 30000;
+        this.LATENCY_DEBUG_THRESHOLD_MS = 1000;
         // private currentPerfomanceMonitor: CurrentPerformanceMonitor[] = [];
         // private idPerformance: number = 0;
         // private performanceThread;
@@ -667,20 +668,55 @@ var SubscriptionManager = /** @class */ (function () {
     };
     // Throttled `loggedInLatency` method
     SubscriptionManager.prototype.loggedInLatency = function (ws) {
-        var loggedInUser = this._loggedInUsers.find(function (a) { return a.id_ws === ws['id_socket']; });
-        if (!loggedInUser)
-            return;
+        var _a, _b, _c, _d;
         var now = new Date();
-        var existingEntry = this.latencyBuffer.get(ws['id_socket']);
         var newLatency = ws['latency'];
+        var socketId = ws['id_socket'];
+        var loggedInUser = this._loggedInUsers.find(function (a) { return a.id_ws === socketId; });
+        if (!loggedInUser) {
+            if (typeof newLatency === 'number' && newLatency >= this.LATENCY_DEBUG_THRESHOLD_MS) {
+                var lastRoute = this._lastRouteBySocket.get(socketId);
+                var workerDispatcher = (_b = (_a = resolveio_server_app_1.ResolveIOServer.getMainServer()) === null || _a === void 0 ? void 0 : _a.getWorkerDispatcherManager) === null || _b === void 0 ? void 0 : _b.call(_a);
+                var workerSnapshot = workerDispatcher && typeof workerDispatcher.getQueueSnapshot === 'function'
+                    ? workerDispatcher.getQueueSnapshot()
+                    : null;
+                console.log(new Date(), '[Latency Spike]', {
+                    latencyMs: (0, common_1.round)(newLatency),
+                    id_user: ws['id_user'] || null,
+                    user: ws['user'] || null,
+                    id_ws: socketId,
+                    lastRoute: (lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.route) || null,
+                    lastRouteAgeMs: lastRoute ? (Date.now() - lastRoute.dateMs) : null,
+                    worker: workerSnapshot
+                });
+            }
+            return;
+        }
+        var existingEntry = this.latencyBuffer.get(socketId);
         // Throttle updates: only update if time threshold has passed or latency has significantly changed
         if (!existingEntry ||
             (now.getTime() - existingEntry.lastUpdate.getTime() >= this.LATENCY_UPDATE_THRESHOLD_MS) ||
             (Math.abs(newLatency - existingEntry.latency) > 100) // Optional: log only significant changes
         ) {
+            if (typeof newLatency === 'number' && newLatency >= this.LATENCY_DEBUG_THRESHOLD_MS) {
+                var lastRoute = this._lastRouteBySocket.get(socketId);
+                var workerDispatcher = (_d = (_c = resolveio_server_app_1.ResolveIOServer.getMainServer()) === null || _c === void 0 ? void 0 : _c.getWorkerDispatcherManager) === null || _d === void 0 ? void 0 : _d.call(_c);
+                var workerSnapshot = workerDispatcher && typeof workerDispatcher.getQueueSnapshot === 'function'
+                    ? workerDispatcher.getQueueSnapshot()
+                    : null;
+                console.log(new Date(), '[Latency Spike]', {
+                    latencyMs: (0, common_1.round)(newLatency),
+                    id_user: loggedInUser.id_user,
+                    user: loggedInUser.user,
+                    id_ws: socketId,
+                    lastRoute: (lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.route) || null,
+                    lastRouteAgeMs: lastRoute ? (Date.now() - lastRoute.dateMs) : null,
+                    worker: workerSnapshot
+                });
+            }
             // Update in-memory and buffer
             loggedInUser.date = now;
-            this.latencyBuffer.set(ws['id_socket'], { latency: newLatency, lastUpdate: now });
+            this.latencyBuffer.set(socketId, { latency: newLatency, lastUpdate: now });
         }
     };
     // Method to flush buffered latency updates in bulk