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

package/src/sync/polling/pollingManagerCS.ts

@@ -6,8 +6,9 @@ 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 { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -22,62 +23,92 @@ export function pollingManagerCSFactory(
 
   const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
+  // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
+  const mySegmentsSyncTasks: Record<string, { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }> = {};
 
   const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
+  const { msSyncTask, mlsSyncTask } = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-      mySegmentsSyncTask.start();
+    const splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
+    const splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
+
+    forOwn(mySegmentsSyncTasks, ({ msSyncTask, 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, ({ msSyncTask, mlsSyncTask }) => {
+      msSyncTask.stop();
+      mlsSyncTask && mlsSyncTask.stop();
     });
   }
 
-  // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
-    const 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: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+    const msSyncTask = mySegmentsSyncTaskFactory(
+      splitApi.fetchMySegments,
+      storage.segments,
+      () => { if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED); },
+      settings,
+      matchingKey,
+      settings.scheduler.segmentsRefreshRate,
+      'mySegmentsUpdater'
+    );
+
+    let mlsSyncTask;
+    if (settings.sync.largeSegmentsEnabled) {
+      mlsSyncTask = mySegmentsSyncTaskFactory(
+        splitApi.fetchMyLargeSegments,
+        storage.largeSegments!,
+        () => { 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 readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
-    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-    return mySegmentsSyncTask;
+    if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+    else setTimeout(smartReady, 0);
+
+    mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
+
+    return {
+      msSyncTask,
+      mlsSyncTask
+    };
   }
 
   return {
     splitsSyncTask,
-    segmentsSyncTask: mySegmentsSyncTask,
+    segmentsSyncTask: msSyncTask,
+    largeSegmentsSyncTask: mlsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      if (storage.splits.usesSegments()) startMySegmentsSyncTasks();
+      startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)
@@ -94,8 +125,9 @@ export function pollingManagerCSFactory(
     // fetch splits and segments
     syncAll() {
       const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-        promises.push(mySegmentsSyncTask.execute());
+      forOwn(mySegmentsSyncTasks, function ({ msSyncTask, mlsSyncTask }) {
+        promises.push(msSyncTask.execute());
+        mlsSyncTask && promises.push(mlsSyncTask.execute());
       });
       return Promise.all(promises);
     },

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -1,5 +1,4 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
 import { syncTaskFactory } from '../../syncTask';
 import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
@@ -12,24 +11,25 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  */
 export function mySegmentsSyncTaskFactory(
   fetchMySegments: IFetchMySegments,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
+  mySegmentsCache: ISegmentsCacheSync,
+  notifyUpdate: () => void,
   settings: ISettings,
-  matchingKey: string
+  matchingKey: string,
+  segmentsRefreshRate: number,
+  NAME: string
 ): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
       mySegmentsFetcherFactory(fetchMySegments),
-      storage.splits,
-      storage.segments,
-      readiness.segments,
+      mySegmentsCache,
+      notifyUpdate,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       matchingKey
     ),
-    settings.scheduler.segmentsRefreshRate,
-    'mySegmentsUpdater',
+    segmentsRefreshRate,
+    NAME,
   );
 }

package/src/sync/polling/types.ts

@@ -20,13 +20,14 @@ export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
   segmentsSyncTask: ISyncTask
+  largeSegmentsSyncTask?: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
   remove(matchingKey: string): void;
-  get(matchingKey: string): IMySegmentsSyncTask | undefined
+  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
 }

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -1,13 +1,11 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
-import { ISegmentsEventEmitter } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 
-type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -18,9 +16,8 @@ type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  splitsCache: ISplitsCacheSync,
   mySegmentsCache: ISegmentsCacheSync,
-  segmentsEventEmitter: ISegmentsEventEmitter,
+  notifyUpdate: () => void,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
@@ -55,9 +52,9 @@ export function mySegmentsUpdaterFactory(
     }
 
     // Notify update if required
-    if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
       readyOnAlreadyExistentState = false;
-      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
+      notifyUpdate();
     }
   }
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -8,6 +8,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 import { ILogger } from '../../../logger/types';
 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';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -33,7 +34,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
     const matchers = conditions[i].matcherGroup.matchers;
 
     matchers.forEach(matcher => {
-      if (matcher.matcherType === 'IN_SEGMENT') segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      if (matcher.matcherType === IN_SEGMENT) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
     });
   }
 
@@ -54,7 +55,7 @@ interface ISplitMutations {
  * @param filters splitFiltersValidation bySet | byName
  */
 function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
-  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter} = filters.groupedFilters;
+  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
   if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
 
   const namesFilterConfigured = namesFilter.length > 0;
@@ -129,7 +130,7 @@ export function splitChangesUpdaterFactory(
 
   /** Returns true if at least one split was updated */
   function isThereUpdate(flagsChange: [boolean | void, void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
-    const [, added, removed, ] = flagsChange;
+    const [, added, removed] = flagsChange;
     // There is at least one added or modified feature flag
     if (added && added.some((update: boolean) => update)) return true;
     // There is at least one removed feature flag

package/src/sync/streaming/SSEHandler/index.ts

@@ -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 { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -83,6 +83,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         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/src/sync/streaming/SSEHandler/types.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE } from '../types';
 
 export interface IMySegmentsUpdateData {
   type: MY_SEGMENTS_UPDATE,
@@ -35,6 +35,18 @@ export interface IMySegmentsUpdateV2Data {
   u: UpdateStrategy,
 }
 
+export interface IMyLargeSegmentsUpdateData {
+  type: MY_LARGE_SEGMENTS_UPDATE,
+  changeNumber: number,
+  largeSegments: string[],
+  c: Compression,
+  d: string,
+  u: UpdateStrategy,
+  i?: number, // time interval in millis
+  h?: number, // hash function. 0 for murmur3_32, 1 for murmur3_64
+  s?: number, // seed for hash function
+}
+
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -68,6 +80,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -1,19 +1,21 @@
 import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
-import { MY_SEGMENT } from '../../../utils/constants';
 import { ITelemetryTracker } from '../../../trackers/types';
+import { UpdatesFromSSEEnum } from '../../submitters/types';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
   let handleNewEvent = false;
   let isHandlingEvent: boolean;
   let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+  let _delay: undefined | number;
+  let _delayTimeoutID: undefined | number;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {
@@ -23,10 +25,18 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       const currentMaxChangeNumber = maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      mySegmentsSyncTask.execute(_segmentsData, true).then((result) => {
+      const syncTask = _delay ?
+        new Promise(res => {
+          _delayTimeoutID = setTimeout(() => {
+            mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+          }, _delay);
+        }) :
+        mySegmentsSyncTask.execute(_segmentsData, true);
+
+      syncTask.then((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);
+          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(updateType);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
         }
         if (handleNewEvent) {
@@ -47,18 +57,20 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
      * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    put(changeNumber: number, segmentsData?: MySegmentsData) {
+    put(changeNumber: number, segmentsData?: MySegmentsData, delay?: number) {
       if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
       maxChangeNumber = changeNumber;
       handleNewEvent = true;
       _segmentsData = segmentsData;
+      _delay = delay;
 
       if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
       backoff.reset();
     },
 
     stop() {
+      clearTimeout(_delayTimeoutID);
       isHandlingEvent = false;
       backoff.reset();
     }

package/src/sync/streaming/constants.ts

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

package/src/sync/streaming/pushManager.ts

@@ -11,17 +11,25 @@ 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 { KeyList, UpdateStrategy } from './SSEHandler/types';
+import { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV2Data, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
+import { hash } from '../../utils/murmur3/murmur3';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
-import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
+import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { IUpdateWorker } from './UpdateWorkers/types';
 
+export function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
+  const interval = parsedData.i || 60000;
+  const seed = parsedData.s || 0;
+
+  return hash(matchingKey, seed) % interval;
+}
+
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -64,7 +72,7 @@ export function pushManagerFactory(
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker }> = {};
+  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker, workerLarge?: IUpdateWorker }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -171,7 +179,10 @@ export function pushManagerFactory(
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
     splitsUpdateWorker.stop();
-    if (userKey) forOwn(clients, ({ worker }) => worker.stop());
+    if (userKey) forOwn(clients, ({ worker, workerLarge }) => {
+      worker.stop();
+      workerLarge && workerLarge.stop();
+    });
     else segmentsUpdateWorker!.stop();
   }
 
@@ -236,76 +247,98 @@ export function pushManagerFactory(
     splitsUpdateWorker.put(parsedData);
   });
 
-  if (userKey) {
-    pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-      const userKeyHash = channel.split('_')[2];
-      const 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: {
-          let bitmap: Uint8Array;
-          try {
-            bitmap = parseBitmap(parsedData.d, parsedData.c);
-          } catch (e) {
-            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
-            break;
-          }
-
-          forOwn(clients, ({ hash64, worker }) => {
-            if (isInBitmap(bitmap, hash64.hex)) {
-              worker.put(parsedData.changeNumber); // fetch mySegments
-            }
-          });
-          return;
+  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData) {
+    const isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+
+    switch (parsedData.u) {
+      case UpdateStrategy.BoundedFetchRequest: {
+        let bitmap: Uint8Array;
+        try {
+          bitmap = parseBitmap(parsedData.d, parsedData.c);
+        } catch (e) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+          break;
         }
-        case UpdateStrategy.KeyList: {
-          let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
-          try {
-            keyList = parseKeyList(parsedData.d, parsedData.c);
-            added = new _Set(keyList.a);
-            removed = new _Set(keyList.r);
-          } catch (e) {
-            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
-            break;
+
+        forOwn(clients, ({ hash64, worker, workerLarge }, matchingKey) => {
+          if (isInBitmap(bitmap, hash64.hex)) {
+            isLS ?
+              workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
+              worker.put(parsedData.changeNumber);
           }
+        });
+        return;
+      }
+      case UpdateStrategy.KeyList: {
+        let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
+        try {
+          keyList = parseKeyList(parsedData.d, parsedData.c);
+          added = new _Set(keyList.a);
+          removed = new _Set(keyList.r);
+        } catch (e) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+          break;
+        }
 
-          forOwn(clients, ({ hash64, worker }) => {
-            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
-            if (add !== undefined) {
+        forOwn(clients, ({ hash64, worker, workerLarge }) => {
+          const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+          if (add !== undefined) {
+            isLS ?
+              workerLarge && workerLarge.put(parsedData.changeNumber, {
+                name: parsedData.largeSegments[0],
+                add
+              }) :
               worker.put(parsedData.changeNumber, {
                 name: parsedData.segmentName,
                 add
               });
-            }
-          });
-          return;
-        }
-        case UpdateStrategy.SegmentRemoval:
-          if (!parsedData.segmentName) {
-            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-            break;
           }
+        });
+        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, ({ worker }) =>
+        forOwn(clients, ({ worker, workerLarge }) => {
+          isLS ?
+            workerLarge && parsedData.largeSegments.forEach(largeSegment => {
+              workerLarge.put(parsedData.changeNumber, {
+                name: largeSegment,
+                add: false
+              });
+            }) :
             worker.put(parsedData.changeNumber, {
               name: parsedData.segmentName,
               add: false
-            })
-          );
-          return;
-      }
+            });
+        });
+        return;
+    }
 
-      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-      forOwn(clients, ({ worker }) => {
+    // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+    forOwn(clients, ({ worker, workerLarge }, matchingKey) => {
+      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) {
+      const userKeyHash = channel.split('_')[2];
+      const 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);
   }
@@ -328,7 +361,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask as IMySegmentsSyncTask); // client-side
+        if (userKey) 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
       },
 
@@ -338,12 +371,16 @@ export function pushManagerFactory(
       },
 
       // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
+      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask) {
         const 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.