@splitsoftware/splitio-commons 1.5.1-rc.0 → 1.5.1-rc.3

package/CHANGES.txt

@@ -1,6 +1,8 @@
-1.6.0 (July 7, 2022)
-- Added `autoRequire` configuration option to the Google Analytics to Split integration (See https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js).
+1.6.0 (July 21, 2022)
+- Added `autoRequire` configuration option to the Google Analytics to Split integration, which takes care of requiring the splitTracker plugin on trackers dynamically created by Google tag managers (See https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js).
 - Updated browser listener to push remaining impressions and events on 'visibilitychange' and 'pagehide' DOM events, instead of 'unload', which is not reliable in mobile and modern Web browsers (See https://developer.chrome.com/blog/page-lifecycle-api/#legacy-lifecycle-apis-to-avoid).
+- Updated the synchronization flow to be more reliable in the event of an edge case generating delay in cache purge propagation, keeping the SDK cache properly synced.
+- Bugfixing - Removed js-yaml dependency to avoid issues in Node v14 when installing third-party dependencies that also uses js-yaml as a transitive dependency (Related to issue https://github.com/splitio/javascript-client/issues/662)
 
 1.5.0 (June 29, 2022)
 - Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online Split will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.

package/cjs/integrations/ga/GaToSplit.js

@@ -26,7 +26,7 @@ function providePlugin(window, pluginName, pluginConstructor, log, autoRequire)
     window[gaAlias]('provide', pluginName, pluginConstructor);
     if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
         // Expecting spy on ga.q push method but not found
-        log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run.');
+        log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
     }
 }
 // Default mapping: object used for building the default mapper from hits to Split events

package/cjs/services/splitApi.js

@@ -37,12 +37,12 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             }
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
         },
-        fetchSplitChanges: function (since, noCache) {
-            var url = urls.sdk + "/splitChanges?since=" + since + (filterQueryString || '');
+        fetchSplitChanges: function (since, noCache, till) {
+            var url = urls.sdk + "/splitChanges?since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SPLITS));
         },
-        fetchSegmentChanges: function (since, segmentName, noCache) {
-            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since;
+        fetchSegmentChanges: function (since, segmentName, noCache, till) {
+            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SEGMENT));
         },
         fetchMySegments: function (userMatchingKey, noCache) {

package/cjs/sync/polling/fetchers/segmentChangesFetcher.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesFetcherFactory = void 0;
 var tslib_1 = require("tslib");
-function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
-    return fetchSegmentChanges(since, segmentName, noCache)
+function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTill) {
+    return fetchSegmentChanges(since, segmentName, noCache, targetTill)
         .then(function (resp) { return resp.json(); })
         .then(function (json) {
         var since = json.since, till = json.till;
@@ -11,7 +11,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
             return [json];
         }
         else {
-            return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(function (flatMe) {
+            return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(function (flatMe) {
                 return (0, tslib_1.__spreadArray)([flatMe[0]], flatMe[1], true);
             });
         }
@@ -22,10 +22,10 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
  * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
  */
 function segmentChangesFetcherFactory(fetchSegmentChanges) {
-    return function segmentChangesFetcher(since, segmentName, noCache, 
+    return function segmentChangesFetcher(since, segmentName, noCache, till, 
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
-        var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache);
+        var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
         if (decorator)
             segmentsPromise = decorator(segmentsPromise);
         return segmentsPromise;

package/cjs/sync/polling/fetchers/splitChangesFetcher.js

@@ -6,10 +6,10 @@ exports.splitChangesFetcherFactory = void 0;
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 function splitChangesFetcherFactory(fetchSplitChanges) {
-    return function splitChangesFetcher(since, noCache, 
+    return function splitChangesFetcher(since, noCache, till, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
-        var splitsPromise = fetchSplitChanges(since, noCache);
+        var splitsPromise = fetchSplitChanges(since, noCache, till);
         if (decorator)
             splitsPromise = decorator(splitsPromise);
         return splitsPromise.then(function (resp) { return resp.json(); });

package/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -18,54 +18,54 @@ var thenable_1 = require("../../../utils/promise/thenable");
  */
 function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
+        log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
+        var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
+        return sincePromise.then(function (since) {
+            // if fetchOnlyNew flag, avoid processing already fetched segments
+            if (fetchOnlyNew && since !== -1)
+                return -1;
+            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                var changeNumber = -1;
+                var results = [];
+                changes.forEach(function (x) {
+                    if (x.added.length > 0)
+                        results.push(segments.addToSegment(segmentName, x.added));
+                    if (x.removed.length > 0)
+                        results.push(segments.removeFromSegment(segmentName, x.removed));
+                    if (x.added.length > 0 || x.removed.length > 0) {
+                        results.push(segments.setChangeNumber(segmentName, x.till));
+                        changeNumber = x.till;
+                    }
+                    log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                });
+                // If at least one storage operation result is a promise, join all in a single promise.
+                if (results.some(function (result) { return (0, thenable_1.thenable)(result); }))
+                    return Promise.all(results).then(function () { return changeNumber; });
+                return changeNumber;
+            });
+        });
+    }
     /**
      * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
      * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
      * Returned promise will not be rejected.
      *
-     * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
-     * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
      * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
      * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+     * @param {string | undefined} segmentName segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+     * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+     * @param {number | undefined} till till target for the provided segmentName, for CDN bypass.
      */
-    return function segmentChangesUpdater(segmentNames, noCache, fetchOnlyNew) {
+    return function segmentChangesUpdater(fetchOnlyNew, segmentName, noCache, till) {
         log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Started segments update");
         // If not a segment name provided, read list of available segments names to be updated.
-        var segmentsPromise = Promise.resolve(segmentNames ? segmentNames : segments.getRegisteredSegments());
+        var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
             // Async fetchers are collected here.
             var updaters = [];
-            var _loop_1 = function (index) {
-                var segmentName = segmentNames[index];
-                log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
-                var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
-                updaters.push(sincePromise.then(function (since) {
-                    // if fetchOnlyNew flag, avoid processing already fetched segments
-                    if (fetchOnlyNew && since !== -1)
-                        return -1;
-                    return segmentChangesFetcher(since, segmentName, noCache).then(function (changes) {
-                        var changeNumber = -1;
-                        var results = [];
-                        changes.forEach(function (x) {
-                            if (x.added.length > 0)
-                                results.push(segments.addToSegment(segmentName, x.added));
-                            if (x.removed.length > 0)
-                                results.push(segments.removeFromSegment(segmentName, x.removed));
-                            if (x.added.length > 0 || x.removed.length > 0) {
-                                results.push(segments.setChangeNumber(segmentName, x.till));
-                                changeNumber = x.till;
-                            }
-                            log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
-                        });
-                        // If at least one storage operation result is a promise, join all in a single promise.
-                        if (results.some(function (result) { return (0, thenable_1.thenable)(result); }))
-                            return Promise.all(results).then(function () { return changeNumber; });
-                        return changeNumber;
-                    });
-                }));
-            };
             for (var index = 0; index < segmentNames.length; index++) {
-                _loop_1(index);
+                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
             }
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -84,16 +84,17 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
      * Returned promise will not be rejected.
      *
      * @param {boolean | undefined} noCache true to revalidate data to fetch
+     * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function splitChangesUpdater(noCache) {
+    return function splitChangesUpdater(noCache, till) {
         /**
          * @param {number} since current changeNumber at splitsCache
-         * @param {number} retry current number of retry attemps
+         * @param {number} retry current number of retry attempts
          */
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(constants_2.SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = splitChangesFetcher(since, noCache, _promiseDecorator)
+            var fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits);

package/cjs/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -3,59 +3,59 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-var MySegmentsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-     */
-    function MySegmentsUpdateWorker(mySegmentsSyncTask) {
-        this.mySegmentsSyncTask = mySegmentsSyncTask;
-        this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-        this.handleNewEvent = false;
-        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-        this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
-        this.put = this.put.bind(this);
-        this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
-        this.backoff = new Backoff_1.Backoff(this.__handleMySegmentsUpdateCall);
-    }
-    // Private method
-    // Precondition: this.mySegmentsSyncTask.isSynchronizingMySegments === false
-    MySegmentsUpdateWorker.prototype.__handleMySegmentsUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.currentChangeNumber) {
-            this.handleNewEvent = false;
-            var currentMaxChangeNumber_1 = this.maxChangeNumber;
+function MySegmentsUpdateWorker(mySegmentsSyncTask) {
+    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+    var currentChangeNumber = -1;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+    var backoff = new Backoff_1.Backoff(__handleMySegmentsUpdateCall);
+    function __handleMySegmentsUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > currentChangeNumber) {
+            handleNewEvent = false;
+            var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
+            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
+                if (!isHandlingEvent)
+                    return; // halt if `stop` has been called
                 if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-                    _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-                if (_this.handleNewEvent) {
-                    _this.__handleMySegmentsUpdateCall();
+                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                if (handleNewEvent) {
+                    __handleMySegmentsUpdateCall();
                 }
                 else {
-                    _this.backoff.scheduleCall();
+                    backoff.scheduleCall();
                 }
             });
         }
+        else {
+            isHandlingEvent = false;
+        }
+    }
+    return {
+        /**
+         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+         *
+         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
+         * @param {SegmentsData | undefined} segmentsData might be undefined
+         */
+        put: function (changeNumber, segmentsData) {
+            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                return;
+            maxChangeNumber = changeNumber;
+            handleNewEvent = true;
+            _segmentsData = segmentsData;
+            if (backoff.timeoutID || !isHandlingEvent)
+                __handleMySegmentsUpdateCall();
+            backoff.reset();
+        },
+        stop: function () {
+            isHandlingEvent = false;
+            backoff.reset();
+        }
     };
-    /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-     *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
-     */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
-        if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        this.segmentsData = segmentsData;
-        if (this.mySegmentsSyncTask.isExecuting())
-            return;
-        this.__handleMySegmentsUpdateCall();
-    };
-    return MySegmentsUpdateWorker;
-}());
+}
 exports.MySegmentsUpdateWorker = MySegmentsUpdateWorker;

package/cjs/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -2,73 +2,91 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_1 = require("./constants");
 /**
- * SegmentUpdateWorker class
+ * SegmentsUpdateWorker factory
  */
-var SegmentsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} segmentsCache segments data cache
-     * @param {Object} segmentsSyncTask task for syncing segments data
-     */
-    function SegmentsUpdateWorker(segmentsSyncTask, segmentsCache) {
-        this.segmentsCache = segmentsCache;
-        this.segmentsSyncTask = segmentsSyncTask;
-        this.maxChangeNumbers = {};
-        this.handleNewEvent = false;
-        this.put = this.put.bind(this);
-        this.__handleSegmentUpdateCall = this.__handleSegmentUpdateCall.bind(this);
-        this.backoff = new Backoff_1.Backoff(this.__handleSegmentUpdateCall);
+function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
+    // Handles retries with CDN bypass per segment name
+    function SegmentUpdateWorker(segment) {
+        var maxChangeNumber = 0;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var backoff = new Backoff_1.Backoff(__handleSegmentUpdateCall, constants_1.FETCH_BACKOFF_BASE, constants_1.FETCH_BACKOFF_MAX_WAIT);
+        function __handleSegmentUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+                handleNewEvent = false;
+                // fetch segments revalidating data if cached
+                segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (handleNewEvent) {
+                        __handleSegmentUpdateCall();
+                    }
+                    else {
+                        var attempts = backoff.attempts + 1;
+                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < constants_1.FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleSegmentUpdateCall();
+                        }
+                    }
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
+        }
+        return {
+            put: function (changeNumber) {
+                var currentChangeNumber = segmentsCache.getChangeNumber(segment);
+                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                    return;
+                maxChangeNumber = changeNumber;
+                handleNewEvent = true;
+                cdnBypass = false;
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleSegmentUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                isHandlingEvent = false;
+                backoff.reset();
+            }
+        };
     }
-    // Private method
-    // Precondition: this.segmentsSyncTask.isSynchronizingSegments === false
-    // Approach similar to MySegmentsUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
-    SegmentsUpdateWorker.prototype.__handleSegmentUpdateCall = function () {
-        var _this = this;
-        var segmentsToFetch = Object.keys(this.maxChangeNumbers).filter(function (segmentName) {
-            return _this.maxChangeNumbers[segmentName] > _this.segmentsCache.getChangeNumber(segmentName);
-        });
-        if (segmentsToFetch.length > 0) {
-            this.handleNewEvent = false;
-            var currentMaxChangeNumbers_1 = segmentsToFetch.map(function (segmentToFetch) { return _this.maxChangeNumbers[segmentToFetch]; });
-            // fetch segments revalidating data if cached
-            this.segmentsSyncTask.execute(segmentsToFetch, true).then(function (result) {
-                // Unlike `SplitUpdateWorker` where changeNumber is consistent between notification and endpoint, if there is no error,
-                // we must clean the `maxChangeNumbers` of those segments that didn't receive a new update notification during the fetch.
-                if (result !== false) {
-                    segmentsToFetch.forEach(function (fetchedSegment, index) {
-                        if (_this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers_1[index])
-                            _this.maxChangeNumbers[fetchedSegment] = -1;
-                    });
-                }
-                else {
-                    // recursive invocation with backoff if there was some error
-                    _this.backoff.scheduleCall();
-                }
-                // immediate recursive invocation if a new notification was queued during fetch
-                if (_this.handleNewEvent) {
-                    _this.__handleSegmentUpdateCall();
-                }
-            });
+    var segments = {};
+    return {
+        /**
+         * Invoked by NotificationProcessor on SEGMENT_UPDATE event
+         *
+         * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
+         * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
+         */
+        put: function (_a) {
+            var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
+            if (!segments[segmentName])
+                segments[segmentName] = SegmentUpdateWorker(segmentName);
+            segments[segmentName].put(changeNumber);
+        },
+        stop: function () {
+            Object.keys(segments).forEach(function (segmentName) { return segments[segmentName].stop(); });
         }
     };
-    /**
-     * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-     *
-     * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-     * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
-     */
-    SegmentsUpdateWorker.prototype.put = function (_a) {
-        var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
-        var currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
-        if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName])
-            return;
-        this.maxChangeNumbers[segmentName] = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        if (this.segmentsSyncTask.isExecuting())
-            return;
-        this.__handleSegmentUpdateCall();
-    };
-    return SegmentsUpdateWorker;
-}());
+}
 exports.SegmentsUpdateWorker = SegmentsUpdateWorker;

package/cjs/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -3,80 +3,96 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplitsUpdateWorker = void 0;
 var constants_1 = require("../../../readiness/constants");
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_2 = require("./constants");
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-var SplitsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} splitsCache splits data cache
-     * @param {Object} splitsSyncTask task for syncing splits data
-     * @param {Object} splitsEventEmitter emitter for splits data events
-     */
-    function SplitsUpdateWorker(splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
-        this.splitsCache = splitsCache;
-        this.splitsSyncTask = splitsSyncTask;
-        this.splitsEventEmitter = splitsEventEmitter;
-        this.segmentsSyncTask = segmentsSyncTask;
-        this.maxChangeNumber = 0;
-        this.handleNewEvent = false;
-        this.put = this.put.bind(this);
-        this.killSplit = this.killSplit.bind(this);
-        this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
-        this.backoff = new Backoff_1.Backoff(this.__handleSplitUpdateCall);
-    }
-    // Private method
-    // Preconditions: this.splitsSyncTask.isSynchronizingSplits === false
-    SplitsUpdateWorker.prototype.__handleSplitUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.splitsCache.getChangeNumber()) {
-            this.handleNewEvent = false;
+function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+    var maxChangeNumber = 0;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var cdnBypass;
+    var backoff = new Backoff_1.Backoff(__handleSplitUpdateCall, constants_2.FETCH_BACKOFF_BASE, constants_2.FETCH_BACKOFF_MAX_WAIT);
+    function __handleSplitUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > splitsCache.getChangeNumber()) {
+            handleNewEvent = false;
             // fetch splits revalidating data if cached
-            this.splitsSyncTask.execute(true).then(function () {
-                if (_this.handleNewEvent) {
-                    _this.__handleSplitUpdateCall();
+            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+                if (!isHandlingEvent)
+                    return; // halt if `stop` has been called
+                if (handleNewEvent) {
+                    __handleSplitUpdateCall();
                 }
                 else {
                     // fetch new registered segments for server-side API. Not retrying on error
-                    if (_this.segmentsSyncTask)
-                        _this.segmentsSyncTask.execute(undefined, false, true);
-                    _this.backoff.scheduleCall();
+                    if (segmentsSyncTask)
+                        segmentsSyncTask.execute(true);
+                    var attempts = backoff.attempts + 1;
+                    if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+                        log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                        isHandlingEvent = false;
+                        return;
+                    }
+                    if (attempts < constants_2.FETCH_BACKOFF_MAX_RETRIES) {
+                        backoff.scheduleCall();
+                        return;
+                    }
+                    if (cdnBypass) {
+                        log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                        isHandlingEvent = false;
+                    }
+                    else {
+                        backoff.reset();
+                        cdnBypass = true;
+                        __handleSplitUpdateCall();
+                    }
                 }
             });
         }
-    };
+        else {
+            isHandlingEvent = false;
+        }
+    }
     /**
      * Invoked by NotificationProcessor on SPLIT_UPDATE event
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (_a) {
+    function put(_a) {
         var changeNumber = _a.changeNumber;
-        var currentChangeNumber = this.splitsCache.getChangeNumber();
-        if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        if (this.splitsSyncTask.isExecuting())
+        var currentChangeNumber = splitsCache.getChangeNumber();
+        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
             return;
-        this.__handleSplitUpdateCall();
-    };
-    /**
-     * Invoked by NotificationProcessor on SPLIT_KILL event
-     *
-     * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-     * @param {string} splitName name of split to kill
-     * @param {string} defaultTreatment default treatment value
-     */
-    SplitsUpdateWorker.prototype.killSplit = function (_a) {
-        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-        if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
-            // trigger an SDK_UPDATE if Split was killed locally
-            this.splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
+        maxChangeNumber = changeNumber;
+        handleNewEvent = true;
+        cdnBypass = false;
+        if (backoff.timeoutID || !isHandlingEvent)
+            __handleSplitUpdateCall();
+        backoff.reset();
+    }
+    return {
+        put: put,
+        /**
+         * Invoked by NotificationProcessor on SPLIT_KILL event
+         *
+         * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+         * @param {string} splitName name of split to kill
+         * @param {string} defaultTreatment default treatment value
+         */
+        killSplit: function (_a) {
+            var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
+            if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+                // trigger an SDK_UPDATE if Split was killed locally
+                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
+            }
+            // queues the SplitChanges fetch (only if changeNumber is newer)
+            put({ changeNumber: changeNumber });
+        },
+        stop: function () {
+            isHandlingEvent = false;
+            backoff.reset();
         }
-        // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put({ changeNumber: changeNumber });
     };
-    return SplitsUpdateWorker;
-}());
+}
 exports.SplitsUpdateWorker = SplitsUpdateWorker;

package/cjs/sync/streaming/UpdateWorkers/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH_BACKOFF_MAX_RETRIES = exports.FETCH_BACKOFF_MAX_WAIT = exports.FETCH_BACKOFF_BASE = void 0;
+exports.FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds
+exports.FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute
+exports.FETCH_BACKOFF_MAX_RETRIES = 10; // max retries