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

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

@@ -1,71 +1,88 @@
 import { Backoff } from '../../../utils/Backoff';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './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(this.__handleSegmentUpdateCall);
+export 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(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, 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 < 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;
-}());
-export { SegmentsUpdateWorker };
+}

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

@@ -1,79 +1,94 @@
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './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(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;
+export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+    var maxChangeNumber = 0;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var cdnBypass;
+    var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, 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 < 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(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(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;
-}());
-export { SplitsUpdateWorker };
+}

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

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

package/esm/sync/streaming/pushManager.js

@@ -42,9 +42,9 @@ export function pushManagerFactory(params, pollingManager) {
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+    var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -137,21 +137,20 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.backoff.reset();
+        splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
-                return worker.backoff.reset();
+                return worker.stop();
             });
         else
-            segmentsUpdateWorker.backoff.reset();
+            segmentsUpdateWorker.stop();
     }
     pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
     // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
     // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
     pushEmitter.on(PUSH_SUBSYSTEM_UP, function () {
         connectPushRetryBackoff.reset();
-        stopWorkers();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
     pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
@@ -287,7 +286,7 @@ export function pushManagerFactory(params, pollingManager) {
             var 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.
                 // Run in next event-loop cycle to save authentication calls

package/esm/sync/syncTask.js

@@ -1,8 +1,7 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
 /**
- * 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.
@@ -12,8 +11,10 @@ import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/co
  */
 export function syncTaskFactory(log, task, period, taskName) {
     if (taskName === void 0) { taskName = 'task'; }
-    // Task promise while it is pending. Undefined once the promise is resolved
-    var pendingTask;
+    // Flag that indicates if the task is executing
+    var executing = 0;
+    // Promise chain to resolve tasks sequentially
+    var promiseChain;
     // flag that indicates if the task periodic execution has been started/stopped.
     var running = false;
     // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -27,19 +28,15 @@ export function syncTaskFactory(log, task, period, taskName) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        // If task is executing, chain the new execution
-        if (pendingTask) {
-            return pendingTask.then(function () {
-                return execute.apply(void 0, args);
-            });
-        }
-        // Execute task
+        executing++;
         log.debug(SYNC_TASK_EXECUTE, [taskName]);
-        pendingTask = task.apply(void 0, args).then(function (result) {
-            pendingTask = undefined;
+        // Update `promiseChain` with last promise, to run tasks serially
+        promiseChain = (promiseChain ? promiseChain.then(function () { return task.apply(void 0, args); }) : task.apply(void 0, args))
+            .then(function (result) {
+            executing--;
             return result;
         });
-        return pendingTask;
+        return promiseChain;
     }
     function periodicExecute(currentRunningId) {
         return execute.apply(void 0, runningArgs).then(function (result) {
@@ -53,7 +50,7 @@ export function syncTaskFactory(log, task, period, taskName) {
     return {
         execute: execute,
         isExecuting: function () {
-            return pendingTask !== undefined;
+            return executing > 0;
         },
         start: function () {
             var args = [];

package/esm/utils/Backoff.js

@@ -7,8 +7,8 @@ var Backoff = /** @class */ (function () {
      * @param {number} maxMillis
      */
     function Backoff(cb, baseMillis, maxMillis) {
-        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;
     }
@@ -22,6 +22,7 @@ var Backoff = /** @class */ (function () {
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
         this.timeoutID = setTimeout(function () {
+            _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
         this.attempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.5.1-rc.0",
+  "version": "1.5.1-rc.1",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/integrations/ga/GaToSplit.ts

@@ -19,26 +19,20 @@ const logNameMapper = 'ga-to-split:mapper';
 /**
  * Provides a plugin to use with analytics.js, accounting for the possibility
  * that the global command queue has been renamed or not yet defined.
- * @param window Reference to global object.
- * @param pluginName The plugin name identifier.
- * @param pluginConstructor The plugin constructor function.
- * @param log Logger instance.
- * @param autoRequire If true, log error when auto-require script is not detected
+ * @param {string} pluginName The plugin name identifier.
+ * @param {Function} pluginConstructor The plugin constructor function.
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(pluginName: string, pluginConstructor: Function) {
   // get reference to global command queue. Init it if not defined yet.
+  // @ts-expect-error
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
-  window[gaAlias] = window[gaAlias] || function () {
-    (window[gaAlias].q = window[gaAlias].q || []).push(arguments);
+  window[gaAlias] = window[gaAlias] || function (...args: any[]) { // @ts-expect-error
+    (window[gaAlias].q = window[gaAlias].q || []).push(args);
   };
 
   // provides the plugin for use with analytics.js.
+  // @ts-expect-error
   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.');
-  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -290,5 +284,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire);
+  providePlugin('splitTracker', SplitTracker);
 }

package/src/integrations/ga/types.ts

@@ -53,24 +53,13 @@ export interface GoogleAnalyticsToSplitOptions {
    * If not provided, events are sent using the key and traffic type provided at SDK config
    */
   identities?: Identity[],
-  /**
-   * Optional flag to log an error if the `auto-require` script is not detected.
-   * The auto-require script automatically requires the `splitTracker` plugin for created trackers,
-   * and should be placed right after your Google Analytics, Google Tag Manager or gtag.js script tag.
-   *
-   * @see {@link https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js}
-   *
-   * @property {boolean} autoRequire
-   * @default false
-   */
-  autoRequire?: boolean,
 }
 
 /**
  * Enable 'Google Analytics to Split' integration, to track Google Analytics hits as Split events.
  * Used by the browser variant of the isomorphic JS SDK.
  *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
+ * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#google-analytics-to-split}
  */
 export interface IGoogleAnalyticsToSplitConfig extends GoogleAnalyticsToSplitOptions {
   type: 'GOOGLE_ANALYTICS_TO_SPLIT'
@@ -140,7 +129,7 @@ export interface SplitToGoogleAnalyticsOptions {
  * Enable 'Split to Google Analytics' integration, to track Split impressions and events as Google Analytics hits.
  * Used by the browser variant of the isomorphic JS SDK.
  *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
+ * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#split-to-google-analytics}
  */
 export interface ISplitToGoogleAnalyticsConfig extends SplitToGoogleAnalyticsOptions {
   type: 'SPLIT_TO_GOOGLE_ANALYTICS'

package/src/services/splitApi.ts

@@ -50,13 +50,13 @@ export function splitApiFactory(
       return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
     },
 
-    fetchSplitChanges(since: number, noCache?: boolean) {
-      const url = `${urls.sdk}/splitChanges?since=${since}${filterQueryString || ''}`;
+    fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/splitChanges?since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
     },
 
-    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean) {
-      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}`;
+    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 

package/src/services/types.ts

@@ -35,9 +35,9 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
-export type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>
+export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
 export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
 

package/src/sync/polling/fetchers/segmentChangesFetcher.ts

@@ -2,15 +2,15 @@ import { IFetchSegmentChanges } from '../../../services/types';
 import { ISegmentChangesResponse } from '../../../dtos/types';
 import { ISegmentChangesFetcher } from './types';
 
-function greedyFetch(fetchSegmentChanges: IFetchSegmentChanges, since: number, segmentName: string, noCache?: boolean): Promise<ISegmentChangesResponse[]> {
-  return fetchSegmentChanges(since, segmentName, noCache)
+function greedyFetch(fetchSegmentChanges: IFetchSegmentChanges, since: number, segmentName: string, noCache?: boolean, targetTill?: number): Promise<ISegmentChangesResponse[]> {
+  return fetchSegmentChanges(since, segmentName, noCache, targetTill)
     .then(resp => resp.json())
     .then((json: ISegmentChangesResponse) => {
       let { since, till } = json;
       if (since === till) {
         return [json];
       } else {
-        return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(flatMe => {
+        return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(flatMe => {
           return [flatMe[0], ...flatMe[1]];
         });
       }
@@ -27,11 +27,12 @@ export function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentC
     since: number,
     segmentName: string,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
   ): Promise<ISegmentChangesResponse[]> {
 
-    let segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache);
+    let segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
     if (decorator) segmentsPromise = decorator(segmentsPromise);
 
     return segmentsPromise;

package/src/sync/polling/fetchers/splitChangesFetcher.ts

@@ -10,11 +10,12 @@ export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges
   return function splitChangesFetcher(
     since: number,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ) {
 
-    let splitsPromise = fetchSplitChanges(since, noCache);
+    let splitsPromise = fetchSplitChanges(since, noCache, till);
     if (decorator) splitsPromise = decorator(splitsPromise);
 
     return splitsPromise.then(resp => resp.json());

package/src/sync/polling/fetchers/types.ts

@@ -4,6 +4,7 @@ import { IResponse } from '../../../services/types';
 export type ISplitChangesFetcher = (
   since: number,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<ISplitChangesResponse>
 
@@ -11,6 +12,7 @@ export type ISegmentChangesFetcher = (
   since: number,
   segmentName: string,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
 ) => Promise<ISegmentChangesResponse[]>