@splitsoftware/splitio-commons 1.15.1-rc.3 → 1.16.1-rc.0

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -23,9 +23,10 @@ function shouldRecordTelemetry(_a) {
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 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;
@@ -41,10 +42,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 () { };
@@ -64,6 +62,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(constants_1.QUEUED),
             eD: this.getEventStats(constants_1.DROPPED),
@@ -195,14 +195,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/cjs/sync/polling/pollingManagerCS.js

@@ -7,6 +7,7 @@ var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
+var constants_3 = require("../../utils/constants");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -15,59 +16,80 @@ function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = (0, splitsSyncTask_1.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 = (0, key_1.getMatching)(settings.core.key);
-    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
+    var _a = add(matchingKey, readiness, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
     function startMySegmentsSyncTasks() {
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            mySegmentsSyncTask.start();
+        var splitsHaveSegments = storage.splits.usesMatcher(constants_3.IN_SEGMENT);
+        var splitsHaveLargeSegments = storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT);
+        (0, lang_1.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() {
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            if (mySegmentsSyncTask.isRunning())
-                mySegmentsSyncTask.stop();
+        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (_a) {
+            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+            msSyncTask.stop();
+            mlsSyncTask && mlsSyncTask.stop();
         });
     }
     // smart pausing
     readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
-        if (!splitsSyncTask.isRunning())
-            return; // noop if not doing polling
-        var splitsHaveSegments = storage.splits.usesSegments();
-        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(constants_2.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 = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+        var msSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage.segments, function () {
+            if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+        }, settings, matchingKey, settings.scheduler.segmentsRefreshRate);
+        var mlsSyncTask;
+        if (settings.sync.largeSegmentsEnabled) {
+            mlsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMyLargeSegments, storage.largeSegments, function () {
+                if (readiness.largeSegments && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
+                    readiness.largeSegments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+            }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate);
+        }
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments())
-                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+            if (!readiness.isReady()) {
+                if (!storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+                    readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+                if (readiness.largeSegments && !storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
+                    readiness.largeSegments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+            }
         }
-        if (!storage.splits.usesSegments())
+        if (!storage.splits.usesMatcher(constants_3.IN_SEGMENT) && !storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
             setTimeout(smartReady, 0);
         else
             readiness.splits.once(constants_1.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(constants_2.POLLING_START);
             splitsSyncTask.start();
-            if (storage.splits.usesSegments())
-                startMySegmentsSyncTasks();
+            startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
@@ -81,8 +103,10 @@ function pollingManagerCSFactory(params) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-                promises.push(mySegmentsSyncTask.execute());
+            (0, lang_1.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/cjs/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -7,7 +7,7 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+function mySegmentsSyncTaskFactory(fetchMySegments, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

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

@@ -2,15 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mySegmentsUpdaterFactory = void 0;
 var timeout_1 = require("../../../utils/promise/timeout");
-var constants_1 = require("../../../readiness/constants");
-var constants_2 = require("../../../logger/constants");
+var constants_1 = require("../../../logger/constants");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notifyUpdate, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -41,9 +40,9 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
             }
         }
         // Notify update if required
-        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+            notifyUpdate();
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {
@@ -60,7 +59,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
         return updaterPromise.catch(function (error) {
             if (startingUp && retriesOnFailureBeforeReady > retry) {
                 retry += 1;
-                log.warn(constants_2.SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
+                log.warn(constants_1.SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
                 return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
             }
             else {
@@ -79,8 +78,14 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
      *  (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);
     };
 }
 exports.mySegmentsUpdaterFactory = mySegmentsUpdaterFactory;

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

@@ -6,6 +6,7 @@ var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var lang_1 = require("../../../utils/lang");
+var constants_3 = require("../../../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
@@ -26,7 +27,7 @@ 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 === constants_3.IN_SEGMENT)
                 segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
         });
     }

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

@@ -76,6 +76,7 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 case constants_1.SPLIT_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
                 case constants_1.MY_SEGMENTS_UPDATE_V2:
+                case constants_1.MY_LARGE_SEGMENTS_UPDATE:
                 case constants_1.SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;

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

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
-var constants_1 = require("../../../utils/constants");
 /**
  * MySegmentsUpdateWorker factory
  */
-function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
+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_1.Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -19,12 +19,12 @@ 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(constants_1.MY_SEGMENT);
+                        telemetryTracker.trackUpdatesFromSSE(updateType);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
                 }
                 if (handleNewEvent) {
@@ -46,12 +46,13 @@ 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/cjs/sync/streaming/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V2 = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.MY_LARGE_SEGMENTS_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V2 = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -30,6 +30,7 @@ exports.MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 exports.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';
+exports.MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 exports.CONTROL = 'CONTROL';
 exports.OCCUPANCY = 'OCCUPANCY';

package/cjs/sync/streaming/pushManager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pushManagerFactory = void 0;
+exports.pushManagerFactory = exports.getDelay = void 0;
 var objectAssign_1 = require("../../utils/lang/objectAssign");
 var Backoff_1 = require("../../utils/Backoff");
 var SSEHandler_1 = require("./SSEHandler");
@@ -16,8 +16,16 @@ var constants_2 = require("../../logger/constants");
 var types_1 = require("./SSEHandler/types");
 var parseUtils_1 = require("./parseUtils");
 var sets_1 = require("../../utils/lang/sets");
+var murmur3_1 = require("../../utils/murmur3/murmur3");
 var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
 var constants_3 = require("../../utils/constants");
+function getDelay(parsedData, matchingKey) {
+    var interval = parsedData.i || 60000;
+    // const hashType = parsedData.h || 0;
+    var seed = parsedData.s || 0;
+    return (0, murmur3_1.hash)(matchingKey, seed) % interval;
+}
+exports.getDelay = getDelay;
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -143,8 +151,9 @@ function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.stop();
         if (userKey)
             (0, lang_1.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();
@@ -198,77 +207,96 @@ function pushManagerFactory(params, pollingManager) {
         }
         splitsUpdateWorker.put(parsedData);
     });
-    if (userKey) {
-        pushEmitter.on(constants_1.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(constants_1.MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-            switch (parsedData.u) {
-                case types_1.UpdateStrategy.BoundedFetchRequest: {
-                    var bitmap_1;
-                    try {
-                        bitmap_1 = (0, parseUtils_1.parseBitmap)(parsedData.d, parsedData.c);
-                    }
-                    catch (e) {
-                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
-                        break;
-                    }
-                    (0, lang_1.forOwn)(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        if ((0, parseUtils_1.isInBitmap)(bitmap_1, hash64.hex)) {
-                            worker.put(parsedData.changeNumber); // fetch mySegments
-                        }
-                    });
-                    return;
+    function handleMySegmentsUpdate(parsedData) {
+        var isLS = parsedData.type === constants_1.MY_LARGE_SEGMENTS_UPDATE;
+        switch (parsedData.u) {
+            case types_1.UpdateStrategy.BoundedFetchRequest: {
+                var bitmap_1;
+                try {
+                    bitmap_1 = (0, parseUtils_1.parseBitmap)(parsedData.d, parsedData.c);
                 }
-                case types_1.UpdateStrategy.KeyList: {
-                    var keyList = void 0, added_1, removed_1;
-                    try {
-                        keyList = (0, parseUtils_1.parseKeyList)(parsedData.d, parsedData.c);
-                        added_1 = new sets_1._Set(keyList.a);
-                        removed_1 = new sets_1._Set(keyList.r);
-                    }
-                    catch (e) {
-                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
-                        break;
+                catch (e) {
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                    break;
+                }
+                (0, lang_1.forOwn)(clients, function (_a, matchingKey) {
+                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    if ((0, parseUtils_1.isInBitmap)(bitmap_1, hash64.hex)) {
+                        isLS ?
+                            workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
+                            worker.put(parsedData.changeNumber);
                     }
-                    (0, lang_1.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 types_1.UpdateStrategy.KeyList: {
+                var keyList = void 0, added_1, removed_1;
+                try {
+                    keyList = (0, parseUtils_1.parseKeyList)(parsedData.d, parsedData.c);
+                    added_1 = new sets_1._Set(keyList.a);
+                    removed_1 = new sets_1._Set(keyList.r);
+                }
+                catch (e) {
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                    break;
+                }
+                (0, lang_1.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 types_1.UpdateStrategy.SegmentRemoval:
-                    if (!parsedData.segmentName) {
-                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-                        break;
                     }
-                    (0, lang_1.forOwn)(clients, function (_a) {
-                        var worker = _a.worker;
-                        return worker.put(parsedData.changeNumber, {
+                });
+                return;
+            }
+            case types_1.UpdateStrategy.SegmentRemoval:
+                if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                    break;
+                }
+                (0, lang_1.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
-            (0, lang_1.forOwn)(clients, function (_a) {
-                var worker = _a.worker;
+                });
+                return;
+        }
+        // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+        (0, lang_1.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(constants_1.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(constants_1.MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+        pushEmitter.on(constants_1.MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
+    }
     else {
         pushEmitter.on(constants_1.SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
@@ -290,7 +318,7 @@ 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
         },
@@ -299,11 +327,15 @@ function pushManagerFactory(params, pollingManager) {
             return disconnected === false;
         },
         // [Only for client-side]
-        add: function (userKey, mySegmentsSyncTask) {
+        add: function (userKey, mySegmentsSyncTask, myLargeSegmentsSyncTask) {
             var hash = (0, AuthClient_1.hashUserKey)(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask, telemetryTracker) };
+                clients[userKey] = {
+                    hash64: (0, murmur3_64_1.hash64)(userKey),
+                    worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask, telemetryTracker, constants_3.MY_SEGMENT),
+                    workerLarge: myLargeSegmentsSyncTask ? (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(myLargeSegmentsSyncTask, telemetryTracker, constants_3.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/cjs/sync/submitters/telemetrySubmitter.js

@@ -65,10 +65,12 @@ function telemetryCacheConfigAdapter(telemetry, settings) {
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return (0, objectAssign_1.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,

package/cjs/sync/syncManagerOnline.js

@@ -117,43 +117,53 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
             shared: function (matchingKey, readinessManager, storage) {
                 if (!pollingManager)
                     return;
-                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
+                var _a = pollingManager.add(matchingKey, readinessManager, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
                 return {
-                    isRunning: mySegmentsSyncTask.isRunning,
+                    isRunning: msSyncTask.isRunning,
                     start: function () {
                         if (syncEnabled) {
                             if (pushManager) {
                                 if (pollingManager.isRunning()) {
                                     // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
+                                    if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+                                        msSyncTask.start();
+                                    if (mlsSyncTask && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
+                                        mlsSyncTask.start();
                                 }
                                 else {
                                     // if not polling, we must execute the sync task for the initial fetch
                                     // of segments since `syncAll` was already executed when starting the main client
-                                    mySegmentsSyncTask.execute();
+                                    msSyncTask.execute();
+                                    mlsSyncTask && mlsSyncTask.execute();
                                 }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
+                                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
                             }
                             else {
-                                if (storage.splits.usesSegments())
-                                    mySegmentsSyncTask.start();
+                                if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+                                    msSyncTask.start();
+                                if (mlsSyncTask && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
+                                    mlsSyncTask.start();
                             }
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (!readinessManager.isReady()) {
+                                msSyncTask.execute();
+                                mlsSyncTask && mlsSyncTask.execute();
+                            }
                         }
                     },
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
-                        var mySegmentsSyncTask = pollingManager.get(matchingKey);
-                        if (mySegmentsSyncTask) {
+                        var syncTasks = pollingManager.get(matchingKey);
+                        if (syncTasks) {
+                            var msSyncTask_1 = syncTasks.msSyncTask, mlsSyncTask_1 = syncTasks.mlsSyncTask;
                             // stop syncing
                             if (pushManager)
                                 pushManager.remove(matchingKey);
-                            if (mySegmentsSyncTask.isRunning())
-                                mySegmentsSyncTask.stop();
+                            if (msSyncTask_1.isRunning())
+                                msSyncTask_1.stop();
+                            if (mlsSyncTask_1 && mlsSyncTask_1.isRunning())
+                                mlsSyncTask_1.stop();
                             pollingManager.remove(matchingKey);
                         }
                     },