@splitsoftware/splitio-commons 1.5.0 → 1.5.1-rc.2

package/CHANGES.txt

@@ -1,3 +1,8 @@
+1.6.0 (July XX, 2022)
+- 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.
 - Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.

package/cjs/listeners/browser.js

@@ -8,11 +8,12 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var telemetrySubmitter_1 = require("../sync/submitters/telemetrySubmitter");
-// 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
-var UNLOAD_DOM_EVENT = 'unload';
+var VISIBILITYCHANGE_EVENT = 'visibilitychange';
+var PAGEHIDE_EVENT = 'pagehide';
+var UNLOAD_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
     function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
@@ -21,33 +22,50 @@ var BrowserSignalListener = /** @class */ (function () {
         this.storage = storage;
         this.serviceApi = serviceApi;
         this.flushData = this.flushData.bind(this);
+        this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
+        this.stopSync = this.stopSync.bind(this);
         this.fromImpressionsCollector = impressionsSubmitter_1.fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
     }
     /**
      * start method.
-     * Called when SplitFactory is initialized.
-     * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
      */
     BrowserSignalListener.prototype.start = function () {
+        this.settings.log.debug(constants_2.CLEANUP_REGISTERING, [EVENT_NAME]);
+        if (typeof document !== 'undefined' && document.addEventListener) {
+            // Flush data whenever the page is hidden or unloaded.
+            document.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+        }
         if (typeof window !== 'undefined' && window.addEventListener) {
-            this.settings.log.debug(constants_2.CLEANUP_REGISTERING, [EVENT_NAME]);
-            window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
+            // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+            window.addEventListener(PAGEHIDE_EVENT, this.flushData);
+            // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+            window.addEventListener(UNLOAD_EVENT, this.stopSync);
         }
     };
     /**
      * stop method.
-     * Called when client is destroyed.
-     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+     * Called when client is destroyed, it removes event listeners.
      */
     BrowserSignalListener.prototype.stop = function () {
+        this.settings.log.debug(constants_2.CLEANUP_DEREGISTERING, [EVENT_NAME]);
+        if (typeof document !== 'undefined' && document.removeEventListener) {
+            document.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+        }
         if (typeof window !== 'undefined' && window.removeEventListener) {
-            this.settings.log.debug(constants_2.CLEANUP_DEREGISTERING, [EVENT_NAME]);
-            window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
+            window.removeEventListener(UNLOAD_EVENT, this.stopSync);
         }
     };
+    BrowserSignalListener.prototype.stopSync = function () {
+        // Close streaming connection
+        if (this.syncManager && this.syncManager.pushManager)
+            this.syncManager.pushManager.stop();
+    };
     /**
      * flushData method.
-     * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
+     * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,
      * using beacon API if possible, or falling back to regular post transport.
      */
     BrowserSignalListener.prototype.flushData = function () {
@@ -71,9 +89,11 @@ var BrowserSignalListener = /** @class */ (function () {
             var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
             this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
-        // Close streaming connection
-        if (this.syncManager.pushManager)
-            this.syncManager.pushManager.stop();
+    };
+    BrowserSignalListener.prototype.flushDataIfHidden = function () {
+        // Precondition: document defined
+        if (document.visibilityState === 'hidden')
+            this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
     };
     BrowserSignalListener.prototype._flushData = function (url, cache, postService, fromCacheToPayload, extraMetadata) {
         // if there is data in cache, send it to backend

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;