@resolveio/server-lib 20.14.13 → 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;
@@ -79,6 +80,7 @@ export declare class SubscriptionManager {
     private resolveLocalOplogResyncIntervalMs;
     private parsePositiveNumber;
     private isChangeStreamUnsupported;
+    private isResumeTokenInvalid;
     private enableLocalOplogFallback;
     getUseLocalOplog(): boolean;
     notifyLocalOplog(collection: string, type?: string): void;

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
@@ -1038,6 +1074,29 @@ var SubscriptionManager = /** @class */ (function () {
         }
         return false;
     };
+    SubscriptionManager.prototype.isResumeTokenInvalid = function (error) {
+        var code = typeof (error === null || error === void 0 ? void 0 : error.code) === 'number' ? error.code : null;
+        var codeName = typeof (error === null || error === void 0 ? void 0 : error.codeName) === 'string' ? error.codeName.toLowerCase() : '';
+        var message = typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' ? error.message.toLowerCase() : '';
+        if (code === 286) {
+            // ChangeStreamHistoryLost
+            return true;
+        }
+        if (codeName.includes('changestreamhistorylost')) {
+            return true;
+        }
+        if (message.includes('resume token') && (message.includes('not found') ||
+            message.includes('not possible') ||
+            message.includes('no longer') ||
+            message.includes('not in the oplog') ||
+            message.includes('too old'))) {
+            return true;
+        }
+        if (message.includes('resume of change stream') && message.includes('not possible')) {
+            return true;
+        }
+        return false;
+    };
     SubscriptionManager.prototype.enableLocalOplogFallback = function (reason, error) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, message;
@@ -1571,8 +1630,16 @@ var SubscriptionManager = /** @class */ (function () {
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
-                                    case 2: return [4 /*yield*/, this._oplog$.close()];
+                                    case 2:
+                                        if (!this.isResumeTokenInvalid(error)) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, this.clearResumeToken()];
                                     case 3:
+                                        _a.sent();
+                                        lastResumeToken_1 = null;
+                                        this.queueFullResync('oplog-resume-token-invalid');
+                                        _a.label = 4;
+                                    case 4: return [4 /*yield*/, this._oplog$.close()];
+                                    case 5:
                                         _a.sent();
                                         return [2 /*return*/];
                                 }