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

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -15,9 +15,11 @@ export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
+    var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
+        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(eventsQueueSize),
@@ -27,6 +29,7 @@ export function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
+            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
@@ -37,6 +40,7 @@ export function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -45,6 +49,7 @@ export function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
+                    this.largeSegments.clear();
                 }
             };
         },

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/storages/pluggable/inMemoryWrapper.js

@@ -5,7 +5,7 @@ import { setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

package/esm/sync/polling/fetchers/mySegmentsFetcher.js

@@ -12,6 +12,10 @@ export function mySegmentsFetcherFactory(fetchMySegments) {
         // Extract segment names
         return mySegmentsPromise
             .then(function (resp) { return resp.json(); })
-            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
+            .then(function (json) {
+            return json.mySegments ?
+                json.mySegments.map(function (segment) { return segment.name; }) :
+                json.myLargeSegments;
+        });
     };
 }

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,74 @@ 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(); // smart pausing
+            if (mlsSyncTask) {
+                if (splitsHaveLargeSegments)
+                    mlsSyncTask.start();
+                else
+                    mlsSyncTask.stop(); // smart pausing
+            }
         });
     }
     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();
-            }
-        }
+        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, 'mySegmentsUpdater');
+        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, 'myLargeSegmentsUpdater');
+        }
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments())
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            if (!readiness.isReady()) {
+                if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
+                    readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
+                if (!storage.splits.usesMatcher(IN_SEGMENT))
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            }
         }
-        if (!storage.splits.usesSegments())
-            setTimeout(smartReady, 0);
-        else
+        if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
             readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-        return mySegmentsSyncTask;
+        else
+            setTimeout(smartReady, 0);
+        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 +94,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, NAME) {
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, NAME);
 }

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) {

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,15 @@
 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 _delayTimeoutID;
     var backoff = new Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -16,12 +17,19 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
             handleNewEvent = false;
             var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
+            var syncTask = _delay ?
+                new Promise(function (res) {
+                    _delayTimeoutID = setTimeout(function () {
+                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+                    }, _delay);
+                }) :
+                mySegmentsSyncTask.execute(_segmentsData, true);
+            syncTask.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,17 +51,19 @@ 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();
         },
         stop: function () {
+            clearTimeout(_delayTimeoutID);
             isHandlingEvent = false;
             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';