@splitsoftware/splitio-commons 1.16.1-rc.10 → 1.16.1-rc.11

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-unused-vars */
+import { IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
 
 /**
@@ -28,7 +30,9 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   /**
    * clear the cache.
    */
-  abstract clear(): void
+  clear() {
+    this.resetSegments({});
+  }
 
   /**
    * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
@@ -49,16 +53,57 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   abstract getKeysCount(): number
 
   /**
-   * For server-side synchronizer: set the change number of `name` segment.
-   * For client-side synchronizer: the method is not used.
+   * For server-side synchronizer: change number of `name` segment.
+   * For client-side synchronizer: change number of mySegments.
    */
-  setChangeNumber(name: string, changeNumber: number): boolean { return true; }
-
+  abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void
   abstract getChangeNumber(name: string): number
 
   /**
    * For server-side synchronizer: the method is not used.
-   * For client-side synchronizer: reset the cache with the given list of segments.
+   * For client-side synchronizer: it resets or updates the cache.
    */
-  resetSegments(names: string[], changeNumber?: number): boolean { return true; }
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(undefined, segmentsData.cn);
+
+    const { added, removed } = segmentsData as MySegmentsData;
+
+    if (added && removed) {
+      let isDiff = false;
+
+      added.forEach(segment => {
+        isDiff = this.addToSegment(segment) || isDiff;
+      });
+
+      removed.forEach(segment => {
+        isDiff = this.removeFromSegment(segment) || isDiff;
+      });
+
+      return isDiff;
+    }
+
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
+
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
+
+    let index = 0;
+
+    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+
+    // Quick path => no changes
+    if (index === names.length && index === storedSegmentKeys.length) return false;
+
+    // Slowest path => add and/or remove segments
+    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeFromSegment(storedSegmentKeys[removeIndex]);
+    }
+
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addToSegment(names[addIndex]);
+    }
+
+    return true;
+  }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -32,7 +32,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean
+  abstract setChangeNumber(changeNumber: number): boolean | void
 
   abstract getChangeNumber(): number
 

package/src/storages/dataLoader.ts

@@ -50,6 +50,6 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
         return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
       });
     }
-    storage.segments.resetSegments(mySegmentsData);
+    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
   };
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -16,22 +16,11 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
-  /**
-   * Removes list of segments from localStorage
-   * @NOTE this method is not being used at the moment.
-   */
-  clear() {
-    this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
-
-    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-    // We could optimize next sentence, since it implies iterating over all localStorage items
-    this.resetSegments([]);
-  }
-
   addToSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) === DEFINED) return false;
       localStorage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
@@ -44,6 +33,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
       localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
@@ -56,41 +46,22 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   *
-   * @param {string[]} names list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(names: string[], changeNumber?: number): boolean {
-    try {
-      if (changeNumber) {
-        localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      } else {
-        localStorage.removeItem(this.keys.buildTillKey());
-      }
-    } catch (e) {
-      this.log.error(e);
-    }
-
-    let isDiff = false;
-    let index;
-
+  getRegisteredSegments(): string[] {
     // Scan current values from localStorage
-    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
+    return Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
       if (segmentName) {
         accum.push(segmentName);
       } else {
-        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
         segmentName = this.keys.extractOldSegmentKey(key);
 
         if (segmentName) { // this was an old segment key, let's clean up.
           const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
           try {
             // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+            if (!localStorage.getItem(newSegmentKey)) {
               localStorage.setItem(newSegmentKey, DEFINED);
               // we are migrating a segment, let's track it.
               accum.push(segmentName);
@@ -104,46 +75,21 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
       return accum;
     }, [] as string[]);
-
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentNames.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentNames.length !== names.length) {
-      isDiff = true;
-
-      storedSegmentNames.forEach(name => this.removeFromSegment(name));
-      names.forEach(name => this.addToSegment(name));
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        storedSegmentNames.forEach(name => this.removeFromSegment(name));
-        names.forEach(name => this.addToSegment(name));
-      }
-    }
-
-    return isDiff;
-  }
-
-  getRegisteredSegments(): string[] {
-    return Object.keys(localStorage).reduce<string[]>((accum, key) => {
-      const segmentName = this.keys.extractSegmentName(key);
-      if (segmentName) accum.push(segmentName);
-      return accum;
-    }, []);
   }
 
   getKeysCount() {
     return 1;
   }
 
+  setChangeNumber(name?: string, changeNumber?: number) {
+    try {
+      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else localStorage.removeItem(this.keys.buildTillKey());
+    } catch (e) {
+      this.log.error(e);
+    }
+  }
+
   getChangeNumber() {
     const n = -1;
     let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -9,17 +9,17 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
   private segmentCache: Record<string, boolean> = {};
   private cn?: number;
 
-  clear() {
-    this.segmentCache = {};
-  }
-
   addToSegment(name: string): boolean {
+    if (this.segmentCache[name]) return false;
+
     this.segmentCache[name] = true;
 
     return true;
   }
 
   removeFromSegment(name: string): boolean {
+    if (!this.segmentCache[name]) return false;
+
     delete this.segmentCache[name];
 
     return true;
@@ -29,49 +29,9 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return this.segmentCache[name] === true;
   }
 
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   * @NOTE based on the way we use segments in the browser, this way is the best option
-   *
-   * @param {string[]} names list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(names: string[], changeNumber?: number): boolean {
-    this.cn = changeNumber;
-    let isDiff = false;
-    let index;
-
-    const storedSegmentKeys = Object.keys(this.segmentCache);
 
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentKeys.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentKeys.length !== names.length) {
-      isDiff = true;
-
-      this.segmentCache = {};
-      names.forEach(s => {
-        this.addToSegment(s);
-      });
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        this.segmentCache = {};
-        names.forEach(s => {
-          this.addToSegment(s);
-        });
-      }
-    }
-
-    return isDiff;
+  setChangeNumber(name?: string, changeNumber?: number) {
+    this.cn = changeNumber;
   }
 
   getChangeNumber() {

package/src/storages/types.ts

@@ -1,4 +1,5 @@
-import { MaybeThenable, ISplit } from '../dtos/types';
+import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { ISet } from '../utils/lang/sets';
@@ -218,7 +219,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   removeSplits(names: string[]): boolean[],
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean,
+  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -268,9 +269,9 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean
+  setChangeNumber(name: string, changeNumber: number): boolean | void
   getChangeNumber(name: string): number
-  resetSegments(names: string[], changeNumber?: number): boolean // only for Sync Client-Side
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 

package/src/sync/polling/types.ts

@@ -1,20 +1,19 @@
-import { IMembershipsResponse, ISplit } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
+import { MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
-export type MySegmentsData = IMembershipsResponse | {
-  /* segment type */
-  isLS?: boolean
-  /* segment name */
-  name: string
-  /* action: `true` for add, and `false` for delete */
-  add: boolean
-}[]
+export type MySegmentsData = {
+  type: MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE
+  cn: number
+  added: string[]
+  removed: string[]
+}
 
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 

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

@@ -6,6 +6,8 @@ import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
+import { IMembershipsResponse } from '../../../dtos/types';
+import { MEMBERSHIP_LS_UPDATE } from '../../streaming/constants';
 
 type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
@@ -36,23 +38,16 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: MySegmentsData) {
+  function updateSegments(segmentsData: IMembershipsResponse | MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Add/Delete the segment names
-      segmentsData.forEach(({ isLS, name, add }) => {
-        const cache = isLS ? largeSegments : segments;
-        if (cache!.isInSegment(name) !== add) {
-          shouldNotifyUpdate = true;
-          if (add) cache!.addToSegment(name);
-          else cache!.removeFromSegment(name);
-        }
-      });
+    if ((segmentsData as MySegmentsData).type !== undefined) {
+      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIP_LS_UPDATE ?
+        largeSegments!.resetSegments(segmentsData as MySegmentsData) :
+        segments.resetSegments(segmentsData as MySegmentsData);
     } else {
-      // Reset the list of segment names
-      shouldNotifyUpdate = segments.resetSegments((segmentsData.ms?.k || []).map((segment) => segment.n), segmentsData.ms?.cn);
-      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData.ls?.k || []).map((segment) => segment.n), segmentsData.ls?.cn) || shouldNotifyUpdate;
+      shouldNotifyUpdate = segments.resetSegments((segmentsData as IMembershipsResponse).ms || {});
+      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
     }
 
     // Notify update if required

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

@@ -14,7 +14,7 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
 
   /**
    * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-   * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+   * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
    */
   return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
     return fetchAuth(userKeys)

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

@@ -1,9 +1,9 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE_V3, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { IControlData, INotificationError, INotificationMessage, IOccupancyData } from './types';
+import { INotificationError, INotificationMessage } from './types';
 import { ILogger } from '../../../logger/types';
 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';
@@ -75,26 +75,24 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
       // we only handle update events if streaming is up
-      // @ts-expect-error
-      const type = parsedData.type || parsedData.t;
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1) return;
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1) return;
 
-      switch (type) {
+      switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MY_SEGMENTS_UPDATE_V3:
-        case MY_LARGE_SEGMENTS_UPDATE:
+        case MEMBERSHIP_MS_UPDATE:
+        case MEMBERSHIP_LS_UPDATE:
         case SPLIT_KILL:
-          pushEmitter.emit(type, parsedData);
+          pushEmitter.emit(parsedData.type, parsedData);
           break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent((parsedData as IOccupancyData).metrics.publishers, channel, timestamp);
+          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
           break;
         case CONTROL:
-          notificationKeeper.handleControlEvent((parsedData as IControlData).controlType, channel, timestamp);
+          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
           break;
 
         default:

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V3 } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -19,8 +19,8 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-interface IMySegmentsUpdateData<T extends string> {
-  t: T,
+interface IMembershipUpdateData<T extends string> {
+  type: T,
   cn: number,
   n?: string[],
   c?: Compression,
@@ -31,9 +31,9 @@ interface IMySegmentsUpdateData<T extends string> {
   s?: number, // seed for hash function
 }
 
-export interface IMySegmentsUpdateV3Data extends IMySegmentsUpdateData<MY_SEGMENTS_UPDATE_V3> { }
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIP_MS_UPDATE> { }
 
-export interface IMyLargeSegmentsUpdateData extends IMySegmentsUpdateData<MY_LARGE_SEGMENTS_UPDATE> { }
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIP_LS_UPDATE> { }
 
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
@@ -68,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | 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

@@ -2,12 +2,12 @@ import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
-import { UpdatesFromSSEEnum } from '../../submitters/types';
+import { MEMBERSHIPS } from '../../../utils/constants';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]> {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -37,7 +37,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       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(updateType);
+          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
         }
         if (handleNewEvent) {
@@ -59,13 +59,14 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
      * @param segmentsData data for KeyList or SegmentRemoval instant updates
      * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
      */
-    put(changeNumber: number, segmentsData?: MySegmentsData, delay?: number) {
+    put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
+      const { type, cn } = mySegmentsData;
       // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay) return;
+      if (cn <= currentChangeNumber || cn <= maxChangeNumber || _delay) return;
 
-      maxChangeNumber = changeNumber;
+      maxChangeNumber = cn;
       handleNewEvent = true;
-      _segmentsData = segmentsData;
+      _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
       _delay = delay;
 
       if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();

package/src/sync/streaming/constants.ts

@@ -25,11 +25,11 @@ 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_V3 = 'MY_SEGMENTS_UPDATE_V3';
+export const MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
+export const MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
 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/parseUtils.ts

@@ -1,7 +1,7 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { hash } from '../../utils/murmur3/murmur3';
-import { Compression, IMyLargeSegmentsUpdateData, KeyList } from './SSEHandler/types';
+import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
 import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
@@ -91,7 +91,7 @@ export function parseFFUpdatePayload(compression: Compression, data: string): IS
 
 const DEFAULT_MAX_INTERVAL = 60000;
 
-export function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
+export function getDelay(parsedData: Pick<IMembershipMSUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
   if (parsedData.h === 0) return 0;
 
   const interval = parsedData.i || DEFAULT_MAX_INTERVAL;