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

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -8,7 +8,7 @@ import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { thenable } from '../../../utils/promise/thenable';
 
-type ISegmentChangesUpdater = (segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean) => Promise<boolean>
+type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
 /**
  * Factory of SegmentChanges updater, a task that:
@@ -30,53 +30,56 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean) {
+    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
+    let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
+
+    return sincePromise.then(since => {
+      // if fetchOnlyNew flag, avoid processing already fetched segments
+      if (fetchOnlyNew && since !== -1) return -1;
+
+      return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+        let changeNumber = -1;
+        const results: MaybeThenable<boolean | void>[] = [];
+        changes.forEach(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(`${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(result => thenable(result))) return Promise.all(results).then(() => 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?: string[], noCache?: boolean, fetchOnlyNew?: boolean) {
+  return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);
 
     // If not a segment name provided, read list of available segments names to be updated.
-    let segmentsPromise = Promise.resolve(segmentNames ? segmentNames : segments.getRegisteredSegments());
+    let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
       // Async fetchers are collected here.
       const updaters: Promise<number>[] = [];
 
       for (let index = 0; index < segmentNames.length; index++) {
-        const segmentName = segmentNames[index];
-        log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
-        let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
-
-        updaters.push(sincePromise.then(since => {
-          // if fetchOnlyNew flag, avoid processing already fetched segments
-          if (fetchOnlyNew && since !== -1) return -1;
-
-          return segmentChangesFetcher(since, segmentName, noCache).then(function (changes) {
-            let changeNumber = -1;
-            const results: MaybeThenable<boolean | void>[] = [];
-            changes.forEach(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(`${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(result => thenable(result))) return Promise.all(results).then(() => changeNumber);
-            return changeNumber;
-          });
-        }));
+        updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
 
       }
 
@@ -103,5 +106,4 @@ export function segmentChangesUpdaterFactory(
         return false;
       });
   };
-
 }

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -8,7 +8,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
-type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>
+type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -109,17 +109,18 @@ export function splitChangesUpdaterFactory(
    * 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?: boolean) {
+  return function splitChangesUpdater(noCache?: boolean, till?: number) {
 
     /**
      * @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: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
 
-      const fetcherPromise = splitChangesFetcher(since, noCache, _promiseDecorator)
+      const fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 

package/src/sync/streaming/SSEHandler/types.ts

@@ -68,10 +68,3 @@ export interface IOccupancyData {
 export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }
-
-export type SegmentsData = string[] | {
-  /* segment name */
-  name: string,
-  /* action: `true` for add, and `false` for delete */
-  add: boolean
-}

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -1,71 +1,62 @@
-import { ISegmentsSyncTask } from '../../polling/types';
+import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
-import { SegmentsData } from '../SSEHandler/types';
 
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-export class MySegmentsUpdateWorker implements IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask): IUpdateWorker {
 
-  private readonly mySegmentsSyncTask: ISegmentsSyncTask;
-  private maxChangeNumber: number;
-  private handleNewEvent: boolean;
-  private segmentsData?: SegmentsData;
-  private currentChangeNumber: number;
-  readonly backoff: Backoff;
+  let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+  let currentChangeNumber = -1;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+  const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
-  /**
-   * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-   */
-  constructor(mySegmentsSyncTask: ISegmentsSyncTask) {
-    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(this.__handleMySegmentsUpdateCall);
-  }
-
-  // Private method
-  // Precondition: this.mySegmentsSyncTask.isSynchronizingMySegments === false
-  __handleMySegmentsUpdateCall() {
-    if (this.maxChangeNumber > this.currentChangeNumber) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumber = this.maxChangeNumber;
+  function __handleMySegmentsUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > currentChangeNumber) {
+      handleNewEvent = false;
+      const currentMaxChangeNumber = maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      this.mySegmentsSyncTask.execute(this.segmentsData, true).then((result) => {
+      mySegmentsSyncTask.execute(_segmentsData, true).then((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); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-        if (this.handleNewEvent) {
-          this.__handleMySegmentsUpdateCall();
+          currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+        if (handleNewEvent) {
+          __handleMySegmentsUpdateCall();
         } else {
-          this.backoff.scheduleCall();
+          backoff.scheduleCall();
         }
       });
+    } else {
+      isHandlingEvent = false;
     }
   }
 
-  /**
-   * 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(changeNumber: number, segmentsData?: 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 {
+    /**
+     * 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(changeNumber: number, segmentsData?: MySegmentsData) {
+      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+
+      maxChangeNumber = changeNumber;
+      handleNewEvent = true;
+      _segmentsData = segmentsData;
+
+      if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
+      backoff.reset();
+    },
+
+    stop() {
+      isHandlingEvent = false;
+      backoff.reset();
+    }
+  };
 }

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -1,84 +1,99 @@
+import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
 import { ISegmentUpdateData } from '../SSEHandler/types';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './constants';
 import { IUpdateWorker } from './types';
 
 /**
- * SegmentUpdateWorker class
+ * SegmentsUpdateWorker factory
  */
-export class SegmentsUpdateWorker implements IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
 
-  private readonly segmentsCache: ISegmentsCacheSync;
-  private readonly segmentsSyncTask: ISegmentsSyncTask;
-  private readonly maxChangeNumbers: Record<string, number>;
-  private handleNewEvent: boolean;
-  readonly backoff: Backoff;
+  // Handles retries with CDN bypass per segment name
+  function SegmentUpdateWorker(segment: string) {
+    let maxChangeNumber = 0;
+    let handleNewEvent = false;
+    let isHandlingEvent: boolean;
+    let cdnBypass: boolean;
+    const backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-  /**
-   * @param {Object} segmentsCache segments data cache
-   * @param {Object} segmentsSyncTask task for syncing segments data
-   */
-  constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync) {
-    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(this.__handleSegmentUpdateCall);
-  }
+    function __handleSegmentUpdateCall() {
+      isHandlingEvent = true;
+      if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+        handleNewEvent = false;
 
-  // Private method
-  // Precondition: this.segmentsSyncTask.isSynchronizingSegments === false
-  // Approach similar to MySegmentsUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
-  __handleSegmentUpdateCall() {
-    const segmentsToFetch = Object.keys(this.maxChangeNumbers).filter((segmentName) => {
-      return this.maxChangeNumbers[segmentName] > this.segmentsCache.getChangeNumber(segmentName);
-    });
-    if (segmentsToFetch.length > 0) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumbers = segmentsToFetch.map(segmentToFetch => this.maxChangeNumbers[segmentToFetch]);
+        // fetch segments revalidating data if cached
+        segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(() => {
+          if (!isHandlingEvent) return; // halt if `stop` has been called
+          if (handleNewEvent) {
+            __handleSegmentUpdateCall();
+          } else {
+            const attempts = backoff.attempts + 1;
 
-      // fetch segments revalidating data if cached
-      this.segmentsSyncTask.execute(segmentsToFetch, true).then((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((fetchedSegment, index) => {
-            if (this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers[index]) this.maxChangeNumbers[fetchedSegment] = -1;
-          });
-        } else {
-          // recursive invocation with backoff if there was some error
-          this.backoff.scheduleCall();
-        }
+            if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+              isHandlingEvent = false;
+              return;
+            }
 
-        // immediate recursive invocation if a new notification was queued during fetch
-        if (this.handleNewEvent) {
-          this.__handleSegmentUpdateCall();
-        }
-      });
-    }
-  }
+            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+              backoff.scheduleCall();
+              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({ changeNumber, segmentName }: ISegmentUpdateData) {
-    const currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
+            if (cdnBypass) {
+              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
+              isHandlingEvent = false;
+            } else {
+              backoff.reset();
+              cdnBypass = true;
+              __handleSegmentUpdateCall();
+            }
+          }
+        });
+      } else {
+        isHandlingEvent = false;
+      }
+    }
 
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName]) return;
+    return {
+      put(changeNumber: number) {
+        const currentChangeNumber = segmentsCache.getChangeNumber(segment);
 
-    this.maxChangeNumbers[segmentName] = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
+        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-    if (this.segmentsSyncTask.isExecuting()) return;
+        maxChangeNumber = changeNumber;
+        handleNewEvent = true;
+        cdnBypass = false;
 
-    this.__handleSegmentUpdateCall();
+        if (backoff.timeoutID || !isHandlingEvent) __handleSegmentUpdateCall();
+        backoff.reset();
+      },
+      stop() {
+        isHandlingEvent = false;
+        backoff.reset();
+      }
+    };
   }
 
+  const segments: Record<string, ReturnType<typeof SegmentUpdateWorker>> = {};
+
+  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({ changeNumber, segmentName }: ISegmentUpdateData) {
+      if (!segments[segmentName]) segments[segmentName] = SegmentUpdateWorker(segmentName);
+      segments[segmentName].put(changeNumber);
+    },
+
+    stop() {
+      Object.keys(segments).forEach(segmentName => segments[segmentName].stop());
+    }
+  };
 }

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,58 +1,63 @@
+import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 import { IUpdateWorker } from './types';
 
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-export class SplitsUpdateWorker implements IUpdateWorker {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
 
-  private readonly splitsCache: ISplitsCacheSync;
-  private readonly splitsSyncTask: ISplitsSyncTask;
-  private readonly splitsEventEmitter: ISplitsEventEmitter;
-  private readonly segmentsSyncTask?: ISegmentsSyncTask;
-  private maxChangeNumber: number;
-  private handleNewEvent: boolean;
-  readonly backoff: Backoff;
+  let maxChangeNumber = 0;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let cdnBypass: boolean;
+  const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-  /**
-   * @param {Object} splitsCache splits data cache
-   * @param {Object} splitsSyncTask task for syncing splits data
-   * @param {Object} splitsEventEmitter emitter for splits data events
-   */
-  constructor(splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask) {
-    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(this.__handleSplitUpdateCall);
-  }
-
-  // Private method
-  // Preconditions: this.splitsSyncTask.isSynchronizingSplits === false
-  __handleSplitUpdateCall() {
-    if (this.maxChangeNumber > this.splitsCache.getChangeNumber()) {
-      this.handleNewEvent = false;
+  function __handleSplitUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > splitsCache.getChangeNumber()) {
+      handleNewEvent = false;
 
       // fetch splits revalidating data if cached
-      this.splitsSyncTask.execute(true).then(() => {
-        if (this.handleNewEvent) {
-          this.__handleSplitUpdateCall();
+      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(() => {
+        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);
+
+          const attempts = backoff.attempts + 1;
+
+          if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+            log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+            isHandlingEvent = false;
+            return;
+          }
+
+          if (attempts < 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;
     }
   }
 
@@ -61,34 +66,41 @@ export class SplitsUpdateWorker implements IUpdateWorker {
    *
    * @param {number} changeNumber change number of the SPLIT_UPDATE notification
    */
-  put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
-    const currentChangeNumber = this.splitsCache.getChangeNumber();
-
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
+  function put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
+    const currentChangeNumber = splitsCache.getChangeNumber();
 
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
+    if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-    if (this.splitsSyncTask.isExecuting()) return;
+    maxChangeNumber = changeNumber;
+    handleNewEvent = true;
+    cdnBypass = false;
 
-    this.__handleSplitUpdateCall();
+    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+    backoff.reset();
   }
 
-  /**
-   * 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({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-    if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
-      // trigger an SDK_UPDATE if Split was killed locally
-      this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
-    }
-    // queues the SplitChanges fetch (only if changeNumber is newer)
-    this.put({ changeNumber });
-  }
+  return {
+    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({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
+      if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+        // trigger an SDK_UPDATE if Split was killed locally
+        splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
+      }
+      // queues the SplitChanges fetch (only if changeNumber is newer)
+      put({ changeNumber });
+    },
+
+    stop() {
+      isHandlingEvent = false;
+      backoff.reset();
+    }
+  };
 }

package/src/sync/streaming/UpdateWorkers/constants.ts

@@ -0,0 +1,3 @@
+export const FETCH_BACKOFF_BASE = 10000;  // backoff base starting at 10 seconds
+export const FETCH_BACKOFF_MAX_WAIT = 60000;  // don't wait for more than 1 minute
+export const FETCH_BACKOFF_MAX_RETRIES = 10; // max retries

package/src/sync/streaming/UpdateWorkers/types.ts

@@ -1,6 +1,4 @@
-import { Backoff } from '../../../utils/Backoff';
-
 export interface IUpdateWorker {
-  readonly backoff: Backoff,
-  put(...args: any[]): void
+  stop(): void // clear scheduled tasks (backoff)
+  put(...args: any[]): void // handle new update event
 }