@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.0

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

@@ -1,66 +1,133 @@
 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 { MEMBERSHIPS } from '../../../utils/constants';
+import { ISegmentsCacheSync, IStorageSync } from '../../../storages/types';
+import { ILogger } from '../../../logger/types';
+import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): 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
-  const backoff = new Backoff(__handleMySegmentsUpdateCall);
-
-  function __handleMySegmentsUpdateCall() {
-    isHandlingEvent = true;
-    if (maxChangeNumber > currentChangeNumber) {
-      handleNewEvent = false;
-      const currentMaxChangeNumber = maxChangeNumber;
-
-      // fetch mySegments revalidating data if cached
-      mySegmentsSyncTask.execute(_segmentsData, true).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);
-          currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-        }
-        if (handleNewEvent) {
-          __handleMySegmentsUpdateCall();
-        } else {
-          backoff.scheduleCall();
-        }
-      });
-    } else {
-      isHandlingEvent = false;
+export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
+
+  let _delay: undefined | number;
+  let _delayTimeoutID: any;
+
+  function createUpdateWorker(mySegmentsCache: ISegmentsCacheSync) {
+
+    let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+    let currentChangeNumber = -1;
+    let handleNewEvent = false;
+    let isHandlingEvent: boolean;
+    let cdnBypass: boolean;
+    let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+    const backoff = new Backoff(__handleMySegmentsUpdateCall);
+
+    function __handleMySegmentsUpdateCall() {
+      isHandlingEvent = true;
+      if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
+        handleNewEvent = false;
+        const currentMaxChangeNumber = maxChangeNumber;
+
+        // fetch mySegments revalidating data if cached
+        const syncTask = _delay ?
+          new Promise(res => {
+            _delayTimeoutID = setTimeout(() => {
+              _delay = undefined;
+              mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
+            }, _delay);
+          }) :
+          mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
+
+        syncTask.then((result) => {
+          if (!isHandlingEvent) return; // halt if `stop` has been called
+          if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
+            const storageChangeNumber = mySegmentsCache.getChangeNumber();
+            currentChangeNumber = storageChangeNumber > -1 ?
+              storageChangeNumber :
+              Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+          }
+          if (handleNewEvent) {
+            __handleMySegmentsUpdateCall();
+          } else {
+            if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
+
+            const attempts = backoff.attempts + 1;
+
+            if (maxChangeNumber <= currentChangeNumber) {
+              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+              isHandlingEvent = false;
+              return;
+            }
+
+            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+              backoff.scheduleCall();
+              return;
+            }
+
+            if (cdnBypass) {
+              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
+              isHandlingEvent = false;
+            } else {
+              backoff.reset();
+              cdnBypass = true;
+              __handleMySegmentsUpdateCall();
+            }
+          }
+        });
+      } else {
+        isHandlingEvent = false;
+      }
     }
+
+    return {
+      /**
+       * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+       *
+       * @param changeNumber change number of the notification
+       * @param segmentsData data for KeyList or SegmentRemoval instant updates
+       * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
+       */
+      put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
+        const { type, cn } = mySegmentsData;
+        // Discard event if it is outdated or there is a pending fetch request (_delay is set), but update target change number
+        if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber) return;
+        maxChangeNumber = cn;
+        if (_delay) return;
+
+        handleNewEvent = true;
+        cdnBypass = false;
+        _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
+        _delay = delay;
+
+        if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
+        backoff.reset();
+      },
+
+      stop() {
+        clearTimeout(_delayTimeoutID);
+        _delay = undefined;
+        isHandlingEvent = false;
+        backoff.reset();
+      }
+    };
   }
 
+  const updateWorkers = {
+    [MEMBERSHIPS_MS_UPDATE]: createUpdateWorker(storage.segments),
+    [MEMBERSHIPS_LS_UPDATE]: createUpdateWorker(storage.largeSegments!),
+  };
+
   return {
-    /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-     *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
-     */
-    put(changeNumber: number, segmentsData?: MySegmentsData) {
-      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
-
-      maxChangeNumber = changeNumber;
-      handleNewEvent = true;
-      _segmentsData = segmentsData;
-
-      if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
-      backoff.reset();
+    put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
+      updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
     },
-
     stop() {
-      isHandlingEvent = false;
-      backoff.reset();
+      updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
+      updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
     }
   };
 }

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

@@ -9,7 +9,7 @@ import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {

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

@@ -14,7 +14,7 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: any[]): void // handle new update event
+  put(...args: T): void // handle new update event
 }

package/src/sync/streaming/constants.ts

@@ -25,8 +25,8 @@ export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 
 // Update-type push notifications, handled by NotificationProcessor
-export const MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export const MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export const MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';

package/src/sync/streaming/parseUtils.ts

@@ -1,6 +1,8 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
-import { Compression, KeyList } from './SSEHandler/types';
+import { hash } from '../../utils/murmur3/murmur3';
+import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -42,7 +44,7 @@ function decompress(data: string, compression: Compression) {
  * @returns {{a?: string[], r?: string[] }}
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss: boolean = true): KeyList {
+export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
   const binKeyList = decompress(data, compression);
   let strKeyList = Uint8ArrayToString(binKeyList);
   // replace numbers to strings, to avoid losing precision
@@ -80,14 +82,20 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined {
-  const avoidPrecisionLoss = false;
-  if (compression > 0)
-    return parseKeyList(data, compression, avoidPrecisionLoss);
-  else
-    return JSON.parse(decodeFromBase64(data));
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
+  return compression > 0 ?
+    parseKeyList(data, compression, false) :
+    JSON.parse(decodeFromBase64(data));
+}
+
+const DEFAULT_MAX_INTERVAL = 60000;
+
+export function getDelay(parsedData: Pick<IMembershipMSUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
+  if (parsedData.h === 0) return 0;
+
+  const interval = parsedData.i || DEFAULT_MAX_INTERVAL;
+  const seed = parsedData.s || 0;
+
+  return hash(matchingKey, seed) % interval;
 }

package/src/sync/streaming/pushManager.ts

@@ -11,16 +11,15 @@ 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 { 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 { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, 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 { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IUpdateWorker } from './UpdateWorkers/types';
 
 /**
  * PushManager factory:
@@ -60,11 +59,11 @@ export function pushManagerFactory(
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
   const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
-  // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
+  // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   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 }> = {};
+  // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -236,76 +235,75 @@ 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: IMembershipMSUpdateData | IMembershipLSUpdateData) {
+    switch (parsedData.u) {
+      case UpdateStrategy.BoundedFetchRequest: {
+        let bitmap: Uint8Array;
+        try {
+          bitmap = parseBitmap(parsedData.d!, parsedData.c!);
+        } catch (e) {
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['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 }, matchingKey) => {
+          if (isInBitmap(bitmap, hash64.hex)) {
+            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
           }
+        });
+        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_MEMBERSHIPS_UPDATE, ['KeyList', e]);
+          break;
+        }
 
-          forOwn(clients, ({ hash64, worker }) => {
-            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
-            if (add !== undefined) {
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add
-              });
-            }
-          });
-          return;
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
+          break;
         }
-        case UpdateStrategy.SegmentRemoval:
-          if (!parsedData.segmentName) {
-            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-            break;
-          }
 
-          forOwn(clients, ({ worker }) =>
-            worker.put(parsedData.changeNumber, {
-              name: parsedData.segmentName,
-              add: false
-            })
-          );
-          return;
+        forOwn(clients, ({ hash64, worker }) => {
+          const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+          if (add !== undefined) {
+            worker.put(parsedData, {
+              added: add ? [parsedData.n![0]] : [],
+              removed: add ? [] : [parsedData.n![0]]
+            });
+          }
+        });
+        return;
       }
+      case UpdateStrategy.SegmentRemoval:
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+          break;
+        }
 
-      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-      forOwn(clients, ({ worker }) => {
-        worker.put(parsedData.changeNumber);
-      });
+        forOwn(clients, ({ worker }) => {
+          worker.put(parsedData, {
+            added: [],
+            removed: parsedData.n!
+          });
+        });
+        return;
+    }
+
+    // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+    forOwn(clients, ({ worker }, matchingKey) => {
+      worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
     });
+  }
+
+  if (userKey) {
+    pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
+    pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
@@ -328,7 +326,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); // client-side
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
@@ -343,7 +341,10 @@ export function pushManagerFactory(
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
-          clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
+          clients[userKey] = {
+            hash64: hash64(userKey),
+            worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
+          };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 
           // Reconnects in case of a new client.

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
+import { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -11,8 +11,8 @@ export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
-export type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export type MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -21,23 +21,23 @@ export type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
-  T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
-  T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
+  T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
+  T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
-  T extends SPLIT_KILL ? ISplitKillData : undefined;
+  T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it
  */
 export interface IPushEventEmitter extends IEventEmitter {
-  once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
-  on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
-  emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
+  once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
+  on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
+  emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>): boolean;
 }
 
 /**

package/src/sync/submitters/types.ts

@@ -103,7 +103,7 @@ export type DROPPED = 1;
 export type DEDUPED = 2;
 export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
 export type EventDataType = QUEUED | DROPPED;
-export type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
+export type UpdatesFromSSEEnum = SPLITS | MEMBERSHIPS;
 
 export type SPLITS = 'sp';
 export type IMPRESSIONS = 'im';
@@ -112,8 +112,8 @@ export type EVENTS = 'ev';
 export type TELEMETRY = 'te';
 export type TOKEN = 'to';
 export type SEGMENT = 'se';
-export type MY_SEGMENT = 'ms';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+export type MEMBERSHIPS = 'ms';
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MEMBERSHIPS;
 
 export type LastSync = Partial<Record<OperationType, number | undefined>>
 export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
@@ -158,8 +158,9 @@ export type TelemetryUsageStats = {
 
 // amount of instant updates that we are doing by avoiding fetching to Split servers
 export type UpdatesFromSSE = {
-  sp: number, // splits
+  sp?: number, // splits
   ms?: number, // my segments
+  mls?: number // my large segments
 }
 
 // 'metrics/usage' JSON request body
@@ -175,12 +176,14 @@ export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   spC?: number, // splitCount
   seC?: number, // segmentCount
   skC?: number, // segmentKeyCount
+  lsC?: number, // largeSegmentCount
+  lskC?: number, // largeSegmentKeyCount
   sL?: number, // sessionLengthMs
   eQ: number, // eventsQueued
   eD: number, // eventsDropped
   sE: Array<StreamingEvent>, // streamingEvents
   t?: Array<string>, // tags
-  ufs?: UpdatesFromSSE, //UpdatesFromSSE
+  ufs?: UpdatesFromSSE, // instant updates
 }
 
 /**

package/src/utils/constants/index.ts

@@ -75,7 +75,7 @@ export const EVENTS = 'ev';
 export const TELEMETRY = 'te';
 export const TOKEN = 'to';
 export const SEGMENT = 'se';
-export const MY_SEGMENT = 'ms';
+export const MEMBERSHIPS = 'ms';
 
 export const TREATMENT = 't';
 export const TREATMENTS = 'ts';
@@ -105,7 +105,8 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAG_SPEC_VERSION = '1.1';
+export const FLAG_SPEC_VERSION = '1.2';
 
 // Matcher types
 export const IN_SEGMENT = 'IN_SEGMENT';
+export const IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/src/utils/settingsValidation/index.ts

@@ -209,11 +209,12 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
   sync.splitFilters = splitFiltersValidation.validFilters;
   sync.__splitFiltersValidation = splitFiltersValidation;
-  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
 
+  // ensure a valid flag spec version
+  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
   // ensure a valid user consent value
   // @ts-ignore, modify readonly prop
-  withDefaults.userConsent = consent(withDefaults);
+  withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
 
   return withDefaults;
 }

package/src/utils/settingsValidation/types.ts

@@ -25,7 +25,7 @@ export interface ISettingsValidationParams {
   /** Localhost mode validator (`settings.sync.localhostMode`) */
   localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
   /** User consent validator (`settings.userConsent`) */
-  consent: (settings: ISettings) => ISettings['userConsent'],
+  consent?: (settings: ISettings) => ISettings['userConsent'],
   /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */
   flagSpec?: (settings: ISettings) => ISettings['sync']['flagSpecVersion']
 }