@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1-rc.5

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, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_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 } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -74,18 +74,21 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       const { parsedData, data, channel, timestamp } = messageWithParsedData;
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
-      // we only handle update events if streaming is up
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1) return;
+      // we only handle update events if streaming is up.
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
+        return;
 
       switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MEMBERSHIPS_MS_UPDATE:
-        case MEMBERSHIPS_LS_UPDATE:
+        case MY_SEGMENTS_UPDATE_V2:
         case SPLIT_KILL:
           pushEmitter.emit(parsedData.type, parsedData);
           break;
+        case MY_SEGMENTS_UPDATE:
+          pushEmitter.emit(parsedData.type, parsedData, channel);
+          break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:

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

@@ -1,5 +1,12 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+
+export interface IMySegmentsUpdateData {
+  type: MY_SEGMENTS_UPDATE,
+  changeNumber: number,
+  includesPayload: boolean,
+  segmentList?: string[]
+}
 
 export enum Compression {
   None = 0,
@@ -19,22 +26,15 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-interface IMembershipUpdateData<T extends string> {
-  type: T,
-  cn: number,
-  n?: string[],
-  c?: Compression,
-  d?: string,
+export interface IMySegmentsUpdateV2Data {
+  type: MY_SEGMENTS_UPDATE_V2,
+  changeNumber: number,
+  segmentName: string,
+  c: Compression,
+  d: string,
   u: UpdateStrategy,
-  i?: number, // time interval in millis
-  h?: number, // hash function
-  s?: number, // seed for hash function
 }
 
-export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> { }
-
-export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> { }
-
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -68,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | 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,133 +1,66 @@
 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(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;
-      }
+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;
     }
-
-    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 {
-    put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
-      updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
+    /**
+     * 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();
     },
+
     stop() {
-      updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
-      updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
+      isHandlingEvent = false;
+      backoff.reset();
     }
   };
 }

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<[ISegmentUpdateData]> {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {
@@ -21,7 +21,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
 
     function __handleSegmentUpdateCall() {
       isHandlingEvent = true;
-      if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+      if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
         handleNewEvent = false;
 
         // fetch segments revalidating data if cached
@@ -32,7 +32,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
           } else {
             const attempts = backoff.attempts + 1;
 
-            if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+            if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
               log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
               isHandlingEvent = false;
               return;
@@ -60,7 +60,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
 
     return {
       put(changeNumber: number) {
-        const currentChangeNumber = segmentsCache.getChangeNumber(segment);
+        const currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
 
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 

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<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker<T extends any[]> {
+export interface IUpdateWorker {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: T): void // handle new update event
+  put(...args: any[]): 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 MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
-export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
+export const MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+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';

package/src/sync/streaming/parseUtils.ts

@@ -1,8 +1,6 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
-import { hash } from '../../utils/murmur3/murmur3';
-import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { ISplit } from '../../dtos/types';
+import { Compression, KeyList } from './SSEHandler/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -44,7 +42,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 = true): KeyList {
+export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss: boolean = true): KeyList {
   const binKeyList = decompress(data, compression);
   let strKeyList = Uint8ArrayToString(binKeyList);
   // replace numbers to strings, to avoid losing precision
@@ -82,20 +80,14 @@ 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): 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;
+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));
 }

package/src/sync/streaming/pushManager.ts

@@ -11,15 +11,16 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-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 { 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 { 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:
@@ -59,11 +60,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 membership update events to the corresponding MySegmentsUpdateWorker
+  // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_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 membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
+  // 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 }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -235,75 +236,76 @@ export function pushManagerFactory(
     splitsUpdateWorker.put(parsedData);
   });
 
-  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;
-        }
-
-        forOwn(clients, ({ hash64, worker }, matchingKey) => {
-          if (isInBitmap(bitmap, hash64.hex)) {
-            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
-          }
-        });
-        return;
+  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);
       }
-      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;
-        }
+    });
+    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;
+          }
 
-        if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
-          break;
+          forOwn(clients, ({ hash64, worker }) => {
+            if (isInBitmap(bitmap, hash64.hex)) {
+              worker.put(parsedData.changeNumber); // fetch mySegments
+            }
+          });
+          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]]
-            });
+        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;
           }
-        });
-        return;
-      }
-      case UpdateStrategy.SegmentRemoval:
-        if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
-          break;
-        }
 
-        forOwn(clients, ({ worker }) => {
-          worker.put(parsedData, {
-            added: [],
-            removed: parsedData.n!
+          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;
-    }
+          return;
+        }
+        case UpdateStrategy.SegmentRemoval:
+          if (!parsedData.segmentName) {
+            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+            break;
+          }
 
-    // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-    forOwn(clients, ({ worker }, matchingKey) => {
-      worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
-    });
-  }
+          forOwn(clients, ({ worker }) =>
+            worker.put(parsedData.changeNumber, {
+              name: parsedData.segmentName,
+              add: false
+            })
+          );
+          return;
+      }
 
-  if (userKey) {
-    pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
-    pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
+      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+      forOwn(clients, ({ worker }) => {
+        worker.put(parsedData.changeNumber);
+      });
+    });
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
@@ -326,7 +328,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask as IMySegmentsSyncTask); // client-side
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
@@ -341,10 +343,7 @@ export function pushManagerFactory(
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
-          clients[userKey] = {
-            hash64: hash64(userKey),
-            worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
-          };
+          clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(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 { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } 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 MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
-export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
+export type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 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 | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
+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
 
 type IParsedData<T extends IPushEvent> =
-  T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
-  T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
+  T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
+  T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
-  T extends SPLIT_KILL ? ISplitKillData : INotificationData;
+  T extends SPLIT_KILL ? ISplitKillData : undefined;
 
 /**
  * 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>) => void): this;
-  on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
-  emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>): boolean;
+  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;
 }
 
 /**