@splitsoftware/splitio-commons 1.16.0 → 1.16.1-rc.0

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,7 +1,8 @@
 import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 import { _Set } from '../../utils/lang/sets';
+import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -13,7 +14,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.splitsWithSegmentsCount = 0;
+        _this.segmentsCount = 0;
+        _this.largeSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -22,7 +24,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.splitsWithSegmentsCount = 0;
+        this.segmentsCount = 0;
+        this.largeSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -32,9 +35,11 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
-                this.splitsWithSegmentsCount--;
-            }
+            // Substract from segments count for the previous version of this Split.
+            if (usesMatcher(previousSplit, IN_SEGMENT))
+                this.segmentsCount--;
+            if (usesMatcher(previousSplit, IN_LARGE_SEGMENT))
+                this.largeSegmentsCount--;
         }
         if (split) {
             // Store the Split.
@@ -44,8 +49,10 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
-            if (usesSegments(split))
-                this.splitsWithSegmentsCount++;
+            if (usesMatcher(split, IN_SEGMENT))
+                this.segmentsCount++;
+            if (usesMatcher(split, IN_LARGE_SEGMENT))
+                this.largeSegmentsCount++;
             return true;
         }
         else {
@@ -63,8 +70,10 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 delete this.ttCache[ttName];
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
-            if (usesSegments(split))
-                this.splitsWithSegmentsCount--;
+            if (usesMatcher(split, IN_SEGMENT))
+                this.segmentsCount--;
+            if (usesMatcher(split, IN_LARGE_SEGMENT))
+                this.largeSegmentsCount--;
             return true;
         }
         else {
@@ -87,8 +96,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
-    SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
+    SplitsCacheInMemory.prototype.usesMatcher = function (matcherType) {
+        return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,9 +18,10 @@ export function shouldRecordTelemetry(_a) {
     return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments) {
+    function TelemetryCacheInMemory(splits, segments, largeSegments) {
         this.splits = splits;
         this.segments = segments;
+        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -36,10 +37,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0
-        };
+        this.updatesFromSSE = {};
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -59,6 +57,8 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
+            lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(QUEUED),
             eD: this.getEventStats(DROPPED),
@@ -190,14 +190,11 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0,
-        };
+        this.updatesFromSSE = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type]++;
+        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/esm/sync/polling/pollingManagerCS.js

@@ -3,7 +3,8 @@ import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -12,59 +13,80 @@ export function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
-    // Map of matching keys to their corresponding MySegmentsSyncTask.
+    // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);
-    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
+    var _a = add(matchingKey, readiness, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
     function startMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            mySegmentsSyncTask.start();
+        var splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
+        var splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
+        forOwn(mySegmentsSyncTasks, function (_a) {
+            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+            if (splitsHaveSegments)
+                msSyncTask.start();
+            else
+                msSyncTask.stop();
+            if (mlsSyncTask) {
+                if (splitsHaveLargeSegments)
+                    mlsSyncTask.start();
+                else
+                    mlsSyncTask.stop();
+            }
         });
     }
     function stopMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            if (mySegmentsSyncTask.isRunning())
-                mySegmentsSyncTask.stop();
+        forOwn(mySegmentsSyncTasks, function (_a) {
+            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+            msSyncTask.stop();
+            mlsSyncTask && mlsSyncTask.stop();
         });
     }
     // smart pausing
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
-        if (!splitsSyncTask.isRunning())
-            return; // noop if not doing polling
-        var splitsHaveSegments = storage.splits.usesSegments();
-        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
-            if (splitsHaveSegments) {
-                startMySegmentsSyncTasks();
-            }
-            else {
-                stopMySegmentsSyncTasks();
-            }
-        }
+        // smart pausing of mySegments polling
+        if (splitsSyncTask.isRunning())
+            startMySegmentsSyncTasks();
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+        var msSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage.segments, function () {
+            if (storage.splits.usesMatcher(IN_SEGMENT))
+                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+        }, settings, matchingKey, settings.scheduler.segmentsRefreshRate);
+        var mlsSyncTask;
+        if (settings.sync.largeSegmentsEnabled) {
+            mlsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMyLargeSegments, storage.largeSegments, function () {
+                if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
+                    readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
+            }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate);
+        }
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments())
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            if (!readiness.isReady()) {
+                if (!storage.splits.usesMatcher(IN_SEGMENT))
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
+                    readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
+            }
         }
-        if (!storage.splits.usesSegments())
+        if (!storage.splits.usesMatcher(IN_SEGMENT) && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
             setTimeout(smartReady, 0);
         else
             readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-        return mySegmentsSyncTask;
+        mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
+        return {
+            msSyncTask: msSyncTask,
+            mlsSyncTask: mlsSyncTask
+        };
     }
     return {
         splitsSyncTask: splitsSyncTask,
-        segmentsSyncTask: mySegmentsSyncTask,
+        segmentsSyncTask: msSyncTask,
+        largeSegmentsSyncTask: mlsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(POLLING_START);
             splitsSyncTask.start();
-            if (storage.splits.usesSegments())
-                startMySegmentsSyncTasks();
+            startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
@@ -78,8 +100,10 @@ export function pollingManagerCSFactory(params) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-                promises.push(mySegmentsSyncTask.execute());
+            forOwn(mySegmentsSyncTasks, function (_a) {
+                var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+                promises.push(msSyncTask.execute());
+                mlsSyncTask && promises.push(mlsSyncTask.execute());
             });
             return Promise.all(promises);
         },

package/esm/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -4,6 +4,6 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+export function mySegmentsSyncTaskFactory(fetchMySegments, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate) {
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, 'mySegmentsUpdater');
 }

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -1,5 +1,4 @@
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 /**
  * factory of MySegments updater, a task that:
@@ -7,7 +6,7 @@ import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notifyUpdate, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -38,9 +37,9 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
             }
         }
         // Notify update if required
-        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
+            notifyUpdate();
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {
@@ -76,7 +75,13 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
      *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
      * @param {boolean | undefined} noCache true to revalidate data to fetch
      */
-    return function mySegmentsUpdater(segmentsData, noCache) {
-        return _mySegmentsUpdater(0, segmentsData, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache, delay) {
+        return delay ?
+            new Promise(function (res) {
+                setTimeout(function () {
+                    _mySegmentsUpdater(0, segmentsData, noCache).then(res);
+                }, delay);
+            }) :
+            _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }

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

@@ -3,6 +3,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
+import { IN_SEGMENT } from '../../../utils/constants';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -23,7 +24,7 @@ export function parseSegments(_a) {
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         matchers.forEach(function (matcher) {
-            if (matcher.matcherType === 'IN_SEGMENT')
+            if (matcher.matcherType === IN_SEGMENT)
                 segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
         });
     }

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -73,6 +73,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 case SPLIT_UPDATE:
                 case SEGMENT_UPDATE:
                 case MY_SEGMENTS_UPDATE_V2:
+                case MY_LARGE_SEGMENTS_UPDATE:
                 case SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;

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

@@ -1,14 +1,14 @@
 import { Backoff } from '../../../utils/Backoff';
-import { MY_SEGMENT } from '../../../utils/constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType) {
     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 _delay;
     var backoff = new Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -16,12 +16,12 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
             handleNewEvent = false;
             var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
+            mySegmentsSyncTask.execute(_segmentsData, true, _delay).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.
                     if (_segmentsData)
-                        telemetryTracker.trackUpdatesFromSSE(MY_SEGMENT);
+                        telemetryTracker.trackUpdatesFromSSE(updateType);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
                 }
                 if (handleNewEvent) {
@@ -43,12 +43,13 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
          * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
          * @param {SegmentsData | undefined} segmentsData might be undefined
          */
-        put: function (changeNumber, segmentsData) {
+        put: function (changeNumber, segmentsData, delay) {
             if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
                 return;
             maxChangeNumber = changeNumber;
             handleNewEvent = true;
             _segmentsData = segmentsData;
+            _delay = delay;
             if (backoff.timeoutID || !isHandlingEvent)
                 __handleMySegmentsUpdateCall();
             backoff.reset();

package/esm/sync/streaming/constants.js

@@ -27,6 +27,7 @@ export var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';
+export var MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 export var CONTROL = 'CONTROL';
 export var OCCUPANCY = 'OCCUPANCY';

package/esm/sync/streaming/pushManager.js

@@ -8,13 +8,20 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
+import { hash } from '../../utils/murmur3/murmur3';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
-import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
+import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
+export function getDelay(parsedData, matchingKey) {
+    var interval = parsedData.i || 60000;
+    // const hashType = parsedData.h || 0;
+    var seed = parsedData.s || 0;
+    return hash(matchingKey, seed) % interval;
+}
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -140,8 +147,9 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
-                var worker = _a.worker;
-                return worker.stop();
+                var worker = _a.worker, workerLarge = _a.workerLarge;
+                worker.stop();
+                workerLarge && workerLarge.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -195,77 +203,96 @@ export function pushManagerFactory(params, pollingManager) {
         }
         splitsUpdateWorker.put(parsedData);
     });
-    if (userKey) {
-        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-            var userKeyHash = channel.split('_')[2];
-            var userKey = userKeyHashes[userKeyHash];
-            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-            }
-        });
-        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-            switch (parsedData.u) {
-                case UpdateStrategy.BoundedFetchRequest: {
-                    var bitmap_1;
-                    try {
-                        bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
-                        break;
-                    }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        if (isInBitmap(bitmap_1, hash64.hex)) {
-                            worker.put(parsedData.changeNumber); // fetch mySegments
-                        }
-                    });
-                    return;
+    function handleMySegmentsUpdate(parsedData) {
+        var isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+        switch (parsedData.u) {
+            case UpdateStrategy.BoundedFetchRequest: {
+                var bitmap_1;
+                try {
+                    bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
-                case UpdateStrategy.KeyList: {
-                    var keyList = void 0, added_1, removed_1;
-                    try {
-                        keyList = parseKeyList(parsedData.d, parsedData.c);
-                        added_1 = new _Set(keyList.a);
-                        removed_1 = new _Set(keyList.r);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
-                        break;
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                    break;
+                }
+                forOwn(clients, function (_a, matchingKey) {
+                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    if (isInBitmap(bitmap_1, hash64.hex)) {
+                        isLS ?
+                            workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
+                            worker.put(parsedData.changeNumber);
                     }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
-                        if (add !== undefined) {
+                });
+                return;
+            }
+            case UpdateStrategy.KeyList: {
+                var keyList = void 0, added_1, removed_1;
+                try {
+                    keyList = parseKeyList(parsedData.d, parsedData.c);
+                    added_1 = new _Set(keyList.a);
+                    removed_1 = new _Set(keyList.r);
+                }
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
+                    if (add !== undefined) {
+                        isLS ?
+                            workerLarge && workerLarge.put(parsedData.changeNumber, {
+                                name: parsedData.largeSegments[0],
+                                add: add
+                            }) :
                             worker.put(parsedData.changeNumber, {
                                 name: parsedData.segmentName,
                                 add: add
                             });
-                        }
-                    });
-                    return;
-                }
-                case UpdateStrategy.SegmentRemoval:
-                    if (!parsedData.segmentName) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-                        break;
                     }
-                    forOwn(clients, function (_a) {
-                        var worker = _a.worker;
-                        return worker.put(parsedData.changeNumber, {
+                });
+                return;
+            }
+            case UpdateStrategy.SegmentRemoval:
+                if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var worker = _a.worker, workerLarge = _a.workerLarge;
+                    isLS ?
+                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
+                            workerLarge.put(parsedData.changeNumber, {
+                                name: largeSegment,
+                                add: false
+                            });
+                        }) :
+                        worker.put(parsedData.changeNumber, {
                             name: parsedData.segmentName,
                             add: false
                         });
-                    });
-                    return;
-            }
-            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-            forOwn(clients, function (_a) {
-                var worker = _a.worker;
+                });
+                return;
+        }
+        // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+        forOwn(clients, function (_a, matchingKey) {
+            var worker = _a.worker, workerLarge = _a.workerLarge;
+            isLS ?
+                workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
                 worker.put(parsedData.changeNumber);
-            });
         });
     }
+    if (userKey) {
+        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
+            var userKeyHash = channel.split('_')[2];
+            var userKey = userKeyHashes[userKeyHash];
+            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
+                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
+            }
+        });
+        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+        pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
+    }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
@@ -287,7 +314,7 @@ export function pushManagerFactory(params, pollingManager) {
                 return;
             disconnected = false;
             if (userKey)
-                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+                this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask); // client-side
             else
                 setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
@@ -296,11 +323,15 @@ export function pushManagerFactory(params, pollingManager) {
             return disconnected === false;
         },
         // [Only for client-side]
-        add: function (userKey, mySegmentsSyncTask) {
+        add: function (userKey, mySegmentsSyncTask, myLargeSegmentsSyncTask) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
+                clients[userKey] = {
+                    hash64: hash64(userKey),
+                    worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
+                    workerLarge: myLargeSegmentsSyncTask ? MySegmentsUpdateWorker(myLargeSegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT) : undefined
+                };
                 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/submitters/telemetrySubmitter.js

@@ -61,10 +61,12 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
+                lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
                 rR: {
                     sp: scheduler.featuresRefreshRate / 1000,
                     se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
                     ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
                     im: scheduler.impressionsRefreshRate / 1000,
                     ev: scheduler.eventsPushRate / 1000,
                     te: scheduler.telemetryRefreshRate / 1000,