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

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
 }

package/src/sync/streaming/pushManager.ts

@@ -1,6 +1,6 @@
 import { IPushEventEmitter, IPushManager } from './types';
 import { ISSEClient } from './SSEClient/types';
-import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
+import { IMySegmentsSyncTask, IPollingManager, ISegmentsSyncTask } from '../polling/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
@@ -20,6 +20,7 @@ import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { IUpdateWorker } from './UpdateWorkers/types';
 
 /**
  * PushManager factory:
@@ -55,15 +56,15 @@ export function pushManagerFactory(
 
   // init workers
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-  const segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+  const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: MySegmentsUpdateWorker }> = {};
+  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -169,9 +170,9 @@ export function pushManagerFactory(
 
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
-    splitsUpdateWorker.backoff.reset();
-    if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
-    else (segmentsUpdateWorker as SegmentsUpdateWorker).backoff.reset();
+    splitsUpdateWorker.stop();
+    if (userKey) forOwn(clients, ({ worker }) => worker.stop());
+    else segmentsUpdateWorker!.stop();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
@@ -180,7 +181,6 @@ export function pushManagerFactory(
   // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
   pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
     connectPushRetryBackoff.reset();
-    stopWorkers();
   });
 
   /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
@@ -294,7 +294,7 @@ export function pushManagerFactory(
       });
     });
   } else {
-    pushEmitter.on(SEGMENT_UPDATE, (segmentsUpdateWorker as SegmentsUpdateWorker).put);
+    pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
 
   return objectAssign(
@@ -315,7 +315,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask as IMySegmentsSyncTask); // client-side
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
@@ -325,12 +325,12 @@ export function pushManagerFactory(
       },
 
       // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
+      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
         const hash = hashUserKey(userKey);
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
-          clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
+          clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask) };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 
           // Reconnects in case of a new client.

package/src/sync/streaming/types.ts

@@ -1,6 +1,6 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { ISegmentsSyncTask } from '../polling/types';
+import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 
@@ -45,6 +45,6 @@ export interface IPushEventEmitter extends IEventEmitter {
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
   // Methods used in client-side, to support multiple clients
-  add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void,
+  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void,
   remove(userKey: string): void
 }

package/src/sync/syncTask.ts

@@ -3,9 +3,8 @@ import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 
 /**
- * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
- * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
+ * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
+ * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -15,8 +14,10 @@ import { ISyncTask } from './types';
  */
 export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
 
-  // Task promise while it is pending. Undefined once the promise is resolved
-  let pendingTask: Promise<Output> | undefined;
+  // Flag that indicates if the task is executing
+  let executing = 0;
+  // Promise chain to resolve tasks sequentially
+  let promiseChain: Promise<Output> | undefined;
   // flag that indicates if the task periodic execution has been started/stopped.
   let running = false;
   // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -27,20 +28,17 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
   let timeoutID: any;
 
   function execute(...args: Input): Promise<Output> {
-    // If task is executing, chain the new execution
-    if (pendingTask) {
-      return pendingTask.then(() => {
-        return execute(...args);
+    executing++;
+    log.debug(SYNC_TASK_EXECUTE, [taskName]);
+
+    // Update `promiseChain` with last promise, to run tasks serially
+    promiseChain = (promiseChain ? promiseChain.then(() => task(...args)) : task(...args))
+      .then(result => {
+        executing--;
+        return result;
       });
-    }
 
-    // Execute task
-    log.debug(SYNC_TASK_EXECUTE, [taskName]);
-    pendingTask = task(...args).then(result => {
-      pendingTask = undefined;
-      return result;
-    });
-    return pendingTask;
+    return promiseChain;
   }
 
   function periodicExecute(currentRunningId: number) {
@@ -56,7 +54,7 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
     execute,
 
     isExecuting() {
-      return pendingTask !== undefined;
+      return executing > 0;
     },
 
     start(...args: Input) {

package/src/utils/Backoff.ts

@@ -1,5 +1,9 @@
 export class Backoff {
 
+  // For testing purposes, assign to overwrite the provided value by param
+  static __TEST__BASE_MILLIS?: number;
+  static __TEST__MAX_MILLIS?: number;
+
   static DEFAULT_BASE_MILLIS = 1000; // 1 second
   static DEFAULT_MAX_MILLIS = 1800000; // 30 minutes
 
@@ -17,8 +21,8 @@ export class Backoff {
    * @param {number} maxMillis
    */
   constructor(cb: (...args: any[]) => any, baseMillis?: number, maxMillis?: number) {
-    this.baseMillis = baseMillis || Backoff.DEFAULT_BASE_MILLIS;
-    this.maxMillis = maxMillis || Backoff.DEFAULT_MAX_MILLIS;
+    this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
+    this.maxMillis = Backoff.__TEST__MAX_MILLIS || maxMillis || Backoff.DEFAULT_MAX_MILLIS;
     this.attempts = 0;
     this.cb = cb;
   }
@@ -32,6 +36,7 @@ export class Backoff {
 
     if (this.timeoutID) clearTimeout(this.timeoutID);
     this.timeoutID = setTimeout(() => {
+      this.timeoutID = undefined;
       this.cb();
     }, delayInMillis);
     this.attempts++;

package/types/integrations/ga/GaToSplitPlugin.d.ts

@@ -0,0 +1,3 @@
+import { IIntegrationFactoryParams } from '../types';
+import { GoogleAnalyticsToSplitOptions } from './types';
+export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): (params: IIntegrationFactoryParams) => void;

package/types/integrations/ga/SplitToGaPlugin.d.ts

@@ -0,0 +1,4 @@
+import { IIntegrationFactoryParams } from '../types';
+import SplitToGa from './SplitToGa';
+import { SplitToGoogleAnalyticsOptions } from './types';
+export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): (params: IIntegrationFactoryParams) => SplitToGa;

package/types/integrations/ga/autoRequire.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Auto-require script to use with GaToSplit integration
+ */
+export declare function autoRequire(): void;

package/types/listeners/browser.d.ts

@@ -4,7 +4,7 @@ import { ISplitApi } from '../services/types';
 import { ISettings } from '../types';
 import { ISyncManager } from '../sync/types';
 /**
- * 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.
  */
 export declare class BrowserSignalListener implements ISignalListener {
     private syncManager;
@@ -15,22 +15,22 @@ export declare class BrowserSignalListener implements ISignalListener {
     constructor(syncManager: ISyncManager | undefined, settings: ISettings, storage: IStorageSync, serviceApi: ISplitApi);
     /**
      * 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.
      */
     start(): void;
     /**
      * 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.
      */
     stop(): void;
+    stopSync(): void;
     /**
      * 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.
      */
     flushData(): void;
+    flushDataIfHidden(): void;
     private _flushData;
     /**
      * _sendBeacon method.

package/types/logger/codes.d.ts

@@ -0,0 +1,2 @@
+import { ICodes } from './types';
+export declare const codes: ICodes;