@resolveio/server-lib 20.14.19 → 20.14.20

package/managers/subscription.manager.d.ts

@@ -55,10 +55,37 @@ export declare class SubscriptionManager {
     private _pendingInvalidations;
     private readonly DEBOUNCE_DELAY;
     private readonly MAX_WAIT_TIME;
+    private _warmupEnabled;
+    private _warmupEndsAtMs;
+    private _warmupQueue;
+    private _warmupQueueKeys;
+    private _warmupTimer;
+    private _warmupInFlight;
+    private _warmupProcessing;
+    private _warmupMaxInFlight;
+    private _warmupMaxPerTick;
+    private _warmupTickMs;
+    private _warmupQueueLimit;
+    private _warmupLogIntervalMs;
+    private _warmupLastLogMs;
+    private _warmupAllowPublications;
     constructor();
     static create(wss: WebSocket.Server, serverConfig: any, monitorManagerFunction: MonitorManagerFunction): SubscriptionManager;
     private initialize;
     private setCacheLimit;
+    private configureWarmup;
+    private parseBoolean;
+    private isWarmupGateActive;
+    private shouldQueueWarmup;
+    private buildWarmupKey;
+    private queueWarmupSubscription;
+    private startWarmupTimer;
+    private stopWarmupTimerIfIdle;
+    private processWarmupQueue;
+    private processWarmupItem;
+    private processWarmupItemWithCleanup;
+    private requeueWarmupItem;
+    private logWarmupStatus;
     invalidatePubsCache(collection: string, type: string, documentId?: any, document?: any): Promise<void>;
     private _executeInvalidation;
     private subscriptionReferencesCollection;

package/managers/subscription.manager.js

@@ -170,6 +170,20 @@ var SubscriptionManager = /** @class */ (function () {
         this._pendingInvalidations = new Map();
         this.DEBOUNCE_DELAY = 100; // 100ms debounce window
         this.MAX_WAIT_TIME = 500; // 500ms maximum delay
+        this._warmupEnabled = false;
+        this._warmupEndsAtMs = 0;
+        this._warmupQueue = [];
+        this._warmupQueueKeys = new Set();
+        this._warmupTimer = null;
+        this._warmupInFlight = 0;
+        this._warmupProcessing = false;
+        this._warmupMaxInFlight = 2;
+        this._warmupMaxPerTick = 2;
+        this._warmupTickMs = 200;
+        this._warmupQueueLimit = 0;
+        this._warmupLogIntervalMs = 10000;
+        this._warmupLastLogMs = 0;
+        this._warmupAllowPublications = new Set();
     }
     SubscriptionManager.create = function (wss, serverConfig, monitorManagerFunction) {
         var _this = this;
@@ -368,6 +382,7 @@ var SubscriptionManager = /** @class */ (function () {
                             this._enableDependencyDebug = process.env.ENABLE_DEPENDENCY_DEBUG === 'true';
                         }
                         this.setCacheLimit();
+                        this.configureWarmup();
                         return [2 /*return*/];
                 }
             });
@@ -381,6 +396,287 @@ var SubscriptionManager = /** @class */ (function () {
             this._heapLimit = this._heapSize * 0.3; // Use 50% of total heap size
         }
     };
+    SubscriptionManager.prototype.configureWarmup = function () {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var config = this.serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var enabledRaw = (_a = process.env.SUBSCRIPTION_WARMUP_ENABLED) !== null && _a !== void 0 ? _a : config['SUBSCRIPTION_WARMUP_ENABLED'];
+        var warmupMs = this.parsePositiveNumber((_b = process.env.SUBSCRIPTION_WARMUP_MS) !== null && _b !== void 0 ? _b : config['SUBSCRIPTION_WARMUP_MS']);
+        var enabled = this.parseBoolean(enabledRaw) || warmupMs > 0;
+        if (!enabled) {
+            this._warmupEnabled = false;
+            return;
+        }
+        var durationMs = warmupMs || 60000;
+        this._warmupEnabled = true;
+        this._warmupEndsAtMs = Date.now() + durationMs;
+        this._warmupTickMs = this.parsePositiveNumber((_c = process.env.SUBSCRIPTION_WARMUP_TICK_MS) !== null && _c !== void 0 ? _c : config['SUBSCRIPTION_WARMUP_TICK_MS']) || this._warmupTickMs;
+        this._warmupMaxPerTick = this.parsePositiveNumber((_d = process.env.SUBSCRIPTION_WARMUP_MAX_PER_TICK) !== null && _d !== void 0 ? _d : config['SUBSCRIPTION_WARMUP_MAX_PER_TICK']) || this._warmupMaxPerTick;
+        this._warmupMaxInFlight = this.parsePositiveNumber((_e = process.env.SUBSCRIPTION_WARMUP_MAX_IN_FLIGHT) !== null && _e !== void 0 ? _e : config['SUBSCRIPTION_WARMUP_MAX_IN_FLIGHT']) || Math.max(1, this._warmupMaxPerTick);
+        this._warmupQueueLimit = this.parsePositiveNumber((_f = process.env.SUBSCRIPTION_WARMUP_QUEUE_LIMIT) !== null && _f !== void 0 ? _f : config['SUBSCRIPTION_WARMUP_QUEUE_LIMIT']) || this._warmupQueueLimit;
+        this._warmupLogIntervalMs = this.parsePositiveNumber((_g = process.env.SUBSCRIPTION_WARMUP_LOG_INTERVAL_MS) !== null && _g !== void 0 ? _g : config['SUBSCRIPTION_WARMUP_LOG_INTERVAL_MS']) || this._warmupLogIntervalMs;
+        var allowRaw = (_h = process.env.SUBSCRIPTION_WARMUP_ALLOW_PUBS) !== null && _h !== void 0 ? _h : config['SUBSCRIPTION_WARMUP_ALLOW_PUBS'];
+        if (typeof allowRaw === 'string' && allowRaw.trim()) {
+            this._warmupAllowPublications = new Set(allowRaw
+                .split(',')
+                .map(function (entry) { return entry.trim(); })
+                .filter(Boolean));
+        }
+        this.startWarmupTimer();
+        console.log(new Date(), 'Sub Manager', 'Warmup enabled', {
+            durationMs: durationMs,
+            tickMs: this._warmupTickMs,
+            maxPerTick: this._warmupMaxPerTick,
+            maxInFlight: this._warmupMaxInFlight,
+            queueLimit: this._warmupQueueLimit,
+            allowPubs: Array.from(this._warmupAllowPublications.values())
+        });
+    };
+    SubscriptionManager.prototype.parseBoolean = 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;
+    };
+    SubscriptionManager.prototype.isWarmupGateActive = function () {
+        return this._warmupEnabled && Date.now() < this._warmupEndsAtMs;
+    };
+    SubscriptionManager.prototype.shouldQueueWarmup = function (publication, messageRoute) {
+        if (!this.isWarmupGateActive()) {
+            return false;
+        }
+        if (messageRoute === 'Bypass') {
+            return false;
+        }
+        if (this._warmupAllowPublications.has(publication)) {
+            return false;
+        }
+        return true;
+    };
+    SubscriptionManager.prototype.buildWarmupKey = function (socketId, messageId, publication, subscriptionData) {
+        var normalizedSubscriptionData = Array.isArray(subscriptionData) ? subscriptionData : [];
+        return "".concat(socketId, ":").concat(messageId, ":").concat(publication, ":").concat(JSON.stringify(normalizedSubscriptionData));
+    };
+    SubscriptionManager.prototype.queueWarmupSubscription = function (params) {
+        var _a;
+        if (!this.isWarmupGateActive()) {
+            return false;
+        }
+        if (this._warmupQueueLimit > 0 && this._warmupQueue.length >= this._warmupQueueLimit) {
+            if (this._enableDebug) {
+                console.log(new Date(), 'Sub Manager', 'Warmup queue full; processing immediately', this._warmupQueue.length);
+            }
+            return false;
+        }
+        var socketId = (_a = params.ws) === null || _a === void 0 ? void 0 : _a['id_socket'];
+        if (!socketId) {
+            return false;
+        }
+        var key = this.buildWarmupKey(socketId, params.messageId, params.publication, params.subscriptionData);
+        if (this._warmupQueueKeys.has(key)) {
+            return true;
+        }
+        this._warmupQueue.push({
+            key: key,
+            socketId: socketId,
+            messageRoute: params.messageRoute,
+            messageDate: params.messageDate,
+            messageId: params.messageId,
+            publication: params.publication,
+            subscriptionData: params.subscriptionData,
+            enqueuedAt: Date.now()
+        });
+        this._warmupQueueKeys.add(key);
+        this.startWarmupTimer();
+        this.logWarmupStatus('queued');
+        return true;
+    };
+    SubscriptionManager.prototype.startWarmupTimer = function () {
+        var _this = this;
+        if (this._warmupTimer) {
+            return;
+        }
+        this._warmupTimer = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.processWarmupQueue()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        console.error(new Date(), 'Sub Manager', 'Warmup queue processing failed', error_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); }, this._warmupTickMs);
+    };
+    SubscriptionManager.prototype.stopWarmupTimerIfIdle = function () {
+        if (!this._warmupTimer) {
+            return;
+        }
+        if (this._warmupQueue.length > 0 || this._warmupInFlight > 0 || this.isWarmupGateActive()) {
+            return;
+        }
+        clearInterval(this._warmupTimer);
+        this._warmupTimer = null;
+    };
+    SubscriptionManager.prototype.processWarmupQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pendingTasks, now, processed, _loop_3, this_3, state_1;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this._warmupProcessing) {
+                            return [2 /*return*/];
+                        }
+                        this._warmupProcessing = true;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 4, 5]);
+                        pendingTasks = [];
+                        now = Date.now();
+                        if (this._warmupEnabled && now >= this._warmupEndsAtMs) {
+                            this._warmupEnabled = false;
+                            console.log(new Date(), 'Sub Manager', 'Warmup window ended', {
+                                queued: this._warmupQueue.length
+                            });
+                        }
+                        if (!this._warmupQueue.length) {
+                            this.stopWarmupTimerIfIdle();
+                            return [2 /*return*/];
+                        }
+                        processed = 0;
+                        _loop_3 = function () {
+                            var item = this_3._warmupQueue.shift();
+                            if (!item) {
+                                return "break";
+                            }
+                            this_3._warmupQueueKeys.delete(item.key);
+                            var wasLastItem = this_3._warmupQueue.length === 0;
+                            var ws = this_3._websocketManager.getWebSocket(item.socketId);
+                            if (!ws || ws.readyState !== ws.OPEN) {
+                                return "continue";
+                            }
+                            var normalizedSubscriptionData = Array.isArray(item.subscriptionData) ? item.subscriptionData : [];
+                            var subscriptionKey = JSON.stringify(normalizedSubscriptionData);
+                            var sub = this_3._subscriptions.find(function (a) { return a.publication === item.publication && a.subscriptionKey === subscriptionKey; });
+                            if (!sub || !((_a = sub.clients) === null || _a === void 0 ? void 0 : _a.length)) {
+                                return "continue";
+                            }
+                            if (sub.running) {
+                                this_3.requeueWarmupItem(item);
+                                processed += 1;
+                                if (wasLastItem) {
+                                    return "break";
+                                }
+                                return "continue";
+                            }
+                            this_3._warmupInFlight += 1;
+                            processed += 1;
+                            pendingTasks.push(this_3.processWarmupItemWithCleanup(item, ws, sub));
+                        };
+                        this_3 = this;
+                        while (this._warmupQueue.length &&
+                            processed < this._warmupMaxPerTick &&
+                            this._warmupInFlight < this._warmupMaxInFlight) {
+                            state_1 = _loop_3();
+                            if (state_1 === "break")
+                                break;
+                        }
+                        if (!pendingTasks.length) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Promise.allSettled(pendingTasks)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        this.logWarmupStatus('tick');
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this._warmupProcessing = false;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.processWarmupItem = function (item, ws, sub) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.processSubscription(sub, ws, item.messageId)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.processWarmupItemWithCleanup = function (item, ws, sub) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, this.processWarmupItem(item, ws, sub)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        error_2 = _a.sent();
+                        console.error(new Date(), 'Sub Manager', 'Warmup item failed', error_2);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._warmupInFlight -= 1;
+                        this.stopWarmupTimerIfIdle();
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.requeueWarmupItem = function (item) {
+        if (this._warmupQueueKeys.has(item.key)) {
+            return;
+        }
+        item.enqueuedAt = Date.now();
+        this._warmupQueue.push(item);
+        this._warmupQueueKeys.add(item.key);
+    };
+    SubscriptionManager.prototype.logWarmupStatus = function (reason) {
+        if (!this._warmupLogIntervalMs) {
+            return;
+        }
+        var now = Date.now();
+        if (now - this._warmupLastLogMs < this._warmupLogIntervalMs) {
+            return;
+        }
+        this._warmupLastLogMs = now;
+        console.log(new Date(), 'Sub Manager', 'Warmup status', {
+            reason: reason,
+            enabled: this._warmupEnabled,
+            endsInMs: this._warmupEnabled ? Math.max(0, this._warmupEndsAtMs - now) : 0,
+            queued: this._warmupQueue.length,
+            inFlight: this._warmupInFlight,
+            maxPerTick: this._warmupMaxPerTick,
+            maxInFlight: this._warmupMaxInFlight
+        });
+    };
     SubscriptionManager.prototype.invalidatePubsCache = function (collection, type, documentId, document) {
         return __awaiter(this, void 0, void 0, function () {
             var queue, debounceKey, now, firstInvalidationTime, waitedTooLong;
@@ -724,7 +1020,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Method to flush buffered latency updates in bulk
     SubscriptionManager.prototype.flushThrottledLatencyUpdates = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var pendingEntries, updates, error_1, pendingEntries_1, pendingEntries_1_1, _a, id_ws, payload, current;
+            var pendingEntries, updates, error_3, pendingEntries_1, pendingEntries_1_1, _a, id_ws, payload, current;
             var e_3, _b;
             var _this = this;
             return __generator(this, function (_c) {
@@ -759,7 +1055,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         return [3 /*break*/, 5];
                     case 3:
-                        error_1 = _c.sent();
+                        error_3 = _c.sent();
                         try {
                             for (pendingEntries_1 = __values(pendingEntries), pendingEntries_1_1 = pendingEntries_1.next(); !pendingEntries_1_1.done; pendingEntries_1_1 = pendingEntries_1.next()) {
                                 _a = __read(pendingEntries_1_1.value, 2), id_ws = _a[0], payload = _a[1];
@@ -776,7 +1072,7 @@ var SubscriptionManager = /** @class */ (function () {
                             }
                             finally { if (e_3) throw e_3.error; }
                         }
-                        console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error_1);
+                        console.error(new Date(), 'Sub Manager', 'Throttled latency batch update failed', error_3);
                         return [3 /*break*/, 5];
                     case 4:
                         this._latencyFlushInProgress = false;
@@ -793,7 +1089,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Subscribe to publication
     SubscriptionManager.prototype.subscribe = function (messageRoute, messageDate, ws, messageId, publication, subscriptionData) {
         return __awaiter(this, void 0, void 0, function () {
-            var pub, valObj, valKeys, rootKeys, i, staleRouteMessage, urlData, urlModule_1, urlNext, otherRouteSubs, normalizedSubscriptionData, subscriptionKey_1, sub;
+            var pub, valObj, valKeys, rootKeys, i, staleRouteMessage, urlData, urlModule_1, urlNext, otherRouteSubs, normalizedSubscriptionData, subscriptionKey_1, sub, queued;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -906,6 +1202,19 @@ var SubscriptionManager = /** @class */ (function () {
                         if (this._enableDebug) {
                             console.log(new Date(), 'New Sub', sub.publication, sub.running, sub.runAgain, sub.clients.length);
                         }
+                        if (this.shouldQueueWarmup(publication, messageRoute)) {
+                            queued = this.queueWarmupSubscription({
+                                ws: ws,
+                                messageRoute: messageRoute,
+                                messageDate: messageDate,
+                                messageId: messageId,
+                                publication: publication,
+                                subscriptionData: normalizedSubscriptionData
+                            });
+                            if (queued) {
+                                return [2 /*return*/];
+                            }
+                        }
                         // Immediately send data to the new client
                         return [4 /*yield*/, this.processSubscription(sub, ws, messageId)];
                     case 2:
@@ -1177,7 +1486,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.loadResumeToken = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var db, doc, error_2;
+            var db, doc, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1191,8 +1500,8 @@ var SubscriptionManager = /** @class */ (function () {
                         doc = _a.sent();
                         return [2 /*return*/, (doc === null || doc === void 0 ? void 0 : doc.token) || null];
                     case 2:
-                        error_2 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error_2);
+                        error_4 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to load oplog resume token', error_4);
                         return [2 /*return*/, null];
                     case 3: return [2 /*return*/];
                 }
@@ -1201,7 +1510,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.saveResumeToken = function (token) {
         return __awaiter(this, void 0, void 0, function () {
-            var db, error_3;
+            var db, error_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1220,8 +1529,8 @@ var SubscriptionManager = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 4];
                     case 3:
-                        error_3 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error_3);
+                        error_5 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to persist oplog resume token', error_5);
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
@@ -1230,7 +1539,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.clearResumeToken = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var db, error_4;
+            var db, error_6;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1244,8 +1553,8 @@ var SubscriptionManager = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 3];
                     case 2:
-                        error_4 = _a.sent();
-                        console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error_4);
+                        error_6 = _a.sent();
+                        console.log(new Date(), 'Sub Manager', 'Failed to clear oplog resume token', error_6);
                         return [3 /*break*/, 3];
                     case 3: return [2 /*return*/];
                 }
@@ -1316,7 +1625,7 @@ var SubscriptionManager = /** @class */ (function () {
     };
     SubscriptionManager.prototype.fullResyncSubscriptions = function (reason) {
         return __awaiter(this, void 0, void 0, function () {
-            var subs, subs_1, subs_1_1, sub, pub, _a, _b, client, ws, _c, e_4_1, e_5_1, error_5;
+            var subs, subs_1, subs_1_1, sub, pub, _a, _b, client, ws, _c, e_4_1, e_5_1, error_7;
             var e_5, _d, e_4, _e;
             var _f, _g, _h, _j, _k;
             return __generator(this, function (_l) {
@@ -1414,8 +1723,8 @@ var SubscriptionManager = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 19: return [3 /*break*/, 21];
                     case 20:
-                        error_5 = _l.sent();
-                        console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error_5);
+                        error_7 = _l.sent();
+                        console.log(new Date(), 'Sub Manager', 'Full resync failed', reason, error_7);
                         return [3 /*break*/, 21];
                     case 21: return [2 /*return*/];
                 }
@@ -1425,7 +1734,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
     SubscriptionManager.prototype.tailOpLog = function (resumeToken) {
         return __awaiter(this, void 0, void 0, function () {
-            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken, error_6, innerError_1, error_7;
+            var watchDatabases, pipeline, lastResumeToken_1, startedWithResumeToken, error_8, innerError_1, error_9;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -1486,9 +1795,9 @@ var SubscriptionManager = /** @class */ (function () {
                         startedWithResumeToken = true;
                         return [3 /*break*/, 16];
                     case 5:
-                        error_6 = _a.sent();
-                        if (!this.isChangeStreamUnsupported(error_6)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_6)];
+                        error_8 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_8)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_8)];
                     case 6:
                         _a.sent();
                         return [2 /*return*/];
@@ -1504,7 +1813,7 @@ var SubscriptionManager = /** @class */ (function () {
                     case 10:
                         _a.sent();
                         lastResumeToken_1 = null;
-                        console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_6);
+                        console.log(new Date(), 'oplog resumeAfter failed, starting fresh', error_8);
                         _a.label = 11;
                     case 11:
                         _a.trys.push([11, 12, , 15]);
@@ -1528,13 +1837,13 @@ var SubscriptionManager = /** @class */ (function () {
                         this._oplog$ = resolveio_server_app_1.ResolveIOServer.getMongoConnection().watch(pipeline, { fullDocument: 'updateLookup' });
                         return [3 /*break*/, 21];
                     case 18:
-                        error_7 = _a.sent();
-                        if (!this.isChangeStreamUnsupported(error_7)) return [3 /*break*/, 20];
-                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_7)];
+                        error_9 = _a.sent();
+                        if (!this.isChangeStreamUnsupported(error_9)) return [3 /*break*/, 20];
+                        return [4 /*yield*/, this.enableLocalOplogFallback('change-stream-unsupported', error_9)];
                     case 19:
                         _a.sent();
                         return [2 /*return*/];
-                    case 20: throw error_7;
+                    case 20: throw error_9;
                     case 21:
                         console.log(new Date(), 'oplog started', startedWithResumeToken ? '(resumeAfter)' : '');
                         this._oplog$.on('change', function (doc) { return __awaiter(_this, void 0, void 0, function () {