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

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

@@ -1,6 +1,8 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
+import { ISegmentsEventEmitter } from '../../../readiness/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';
@@ -16,13 +18,14 @@ type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => P
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  storage: IStorageSync,
+  segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
 ): IMySegmentsUpdater {
 
+  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -37,24 +40,25 @@ export function mySegmentsUpdaterFactory(
 
     let shouldNotifyUpdate;
     if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(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);
+        }
+      });
     } else {
-      // Add/Delete the segment
-      const { name, add } = segmentsData;
-      if (mySegmentsCache.isInSegment(name) !== add) {
-        shouldNotifyUpdate = true;
-        if (add) mySegmentsCache.addToSegment(name);
-        else mySegmentsCache.removeFromSegment(name);
-      } else {
-        shouldNotifyUpdate = false;
-      }
+      // 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;
     }
 
     // Notify update if required
-    if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      notifyUpdate();
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 

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

@@ -76,12 +76,10 @@ export class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    const channelsQueryParam = Object.keys(authToken.channels).map(
-      function (channel) {
-        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-        return encodeURIComponent(params + channel);
-      }
-    ).join(',');
+    const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {
+      const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+      return encodeURIComponent(params + channel);
+    }).join(',');
     const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
 
     this.connection = new this.eventSource!(

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, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+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 { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { INotificationError, INotificationMessage } from './types';
+import { IControlData, INotificationError, INotificationMessage, IOccupancyData } 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';
@@ -74,29 +74,27 @@ 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
+      // @ts-expect-error
+      const type = parsedData.type || parsedData.t;
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1) return;
 
-      switch (parsedData.type) {
+      switch (type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MY_SEGMENTS_UPDATE_V2:
+        case MY_SEGMENTS_UPDATE_V3:
         case MY_LARGE_SEGMENTS_UPDATE:
         case SPLIT_KILL:
-          pushEmitter.emit(parsedData.type, parsedData);
-          break;
-        case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(parsedData.type, parsedData, channel);
+          pushEmitter.emit(type, parsedData);
           break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
+          notificationKeeper.handleOccupancyEvent((parsedData as IOccupancyData).metrics.publishers, channel, timestamp);
           break;
         case CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
+          notificationKeeper.handleControlEvent((parsedData as IControlData).controlType, channel, timestamp);
           break;
 
         default:

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

@@ -1,12 +1,5 @@
 import { ControlType } from '../constants';
-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,
-  changeNumber: number,
-  includesPayload: boolean,
-  segmentList?: string[]
-}
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V3 } from '../types';
 
 export enum Compression {
   None = 0,
@@ -26,27 +19,22 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-export interface IMySegmentsUpdateV2Data {
-  type: MY_SEGMENTS_UPDATE_V2,
-  changeNumber: number,
-  segmentName: string,
-  c: Compression,
-  d: string,
-  u: UpdateStrategy,
-}
-
-export interface IMyLargeSegmentsUpdateData {
-  type: MY_LARGE_SEGMENTS_UPDATE,
-  changeNumber: number,
-  largeSegments: string[],
-  c: Compression,
-  d: string,
+interface IMySegmentsUpdateData<T extends string> {
+  t: T,
+  cn: number,
+  n?: 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
+  h?: number, // hash function
   s?: number, // seed for hash function
 }
 
+export interface IMySegmentsUpdateV3Data extends IMySegmentsUpdateData<MY_SEGMENTS_UPDATE_V3> { }
+
+export interface IMyLargeSegmentsUpdateData extends IMySegmentsUpdateData<MY_LARGE_SEGMENTS_UPDATE> { }
+
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -80,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateV3Data | 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

@@ -7,7 +7,7 @@ import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -15,7 +15,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
   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;
+  let _delayTimeoutID: any;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {
@@ -28,6 +28,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       const syncTask = _delay ?
         new Promise(res => {
           _delayTimeoutID = setTimeout(() => {
+            _delay = undefined;
             mySegmentsSyncTask.execute(_segmentsData, true).then(res);
           }, _delay);
         }) :
@@ -35,7 +36,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 (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
           if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(updateType);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
         }
@@ -52,13 +53,15 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
   return {
     /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+     * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
      *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
+     * @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(changeNumber: number, segmentsData?: MySegmentsData, delay?: number) {
-      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+      // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay) return;
 
       maxChangeNumber = changeNumber;
       handleNewEvent = true;
@@ -71,6 +74,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
     stop() {
       clearTimeout(_delayTimeoutID);
+      _delay = undefined;
       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 {
+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,7 @@ 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 MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 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, IMyLargeSegmentsUpdateData, 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<IMyLargeSegmentsUpdateData, '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,24 +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, 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 { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV2Data, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { MY_SEGMENTS_UPDATE_V3, 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, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV3Data, KeyList, UpdateStrategy } from './SSEHandler/types';
+import { getDelay, 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, 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:
@@ -71,8 +62,8 @@ export function pushManagerFactory(
   // [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 MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker, workerLarge?: IUpdateWorker }> = {};
+  // Hash64 is used to process MY_SEGMENTS_UPDATE events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker>, workerLarge: 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;
@@ -181,7 +172,7 @@ export function pushManagerFactory(
     splitsUpdateWorker.stop();
     if (userKey) forOwn(clients, ({ worker, workerLarge }) => {
       worker.stop();
-      workerLarge && workerLarge.stop();
+      workerLarge.stop();
     });
     else segmentsUpdateWorker!.stop();
   }
@@ -247,24 +238,22 @@ export function pushManagerFactory(
     splitsUpdateWorker.put(parsedData);
   });
 
-  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData) {
-    const isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData) {
+    const isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
 
     switch (parsedData.u) {
       case UpdateStrategy.BoundedFetchRequest: {
         let bitmap: Uint8Array;
         try {
-          bitmap = parseBitmap(parsedData.d, parsedData.c);
+          bitmap = parseBitmap(parsedData.d!, parsedData.c!);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['BoundedFetchRequest', 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);
+            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
           }
         });
         return;
@@ -272,72 +261,56 @@ export function pushManagerFactory(
       case UpdateStrategy.KeyList: {
         let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
         try {
-          keyList = parseKeyList(parsedData.d, parsedData.c);
+          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]);
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+          break;
+        }
+
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', 'No segment name was provided']);
           break;
         }
 
         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
-              });
+            (isLS ? workerLarge : worker).put(parsedData.cn, [{
+              isLS,
+              name: parsedData.n![0],
+              add,
+            }]);
           }
         });
         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']);
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
           break;
         }
 
         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
-            });
+          (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n!.map(largeSegment => ({
+            isLS,
+            name: largeSegment,
+            add: false,
+            cn: parsedData.cn
+          })));
         });
         return;
     }
 
     // `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);
+      (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
     });
   }
 
   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_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
     pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
@@ -361,7 +334,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask!); // 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
       },
 
@@ -371,7 +344,7 @@ export function pushManagerFactory(
       },
 
       // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask) {
+      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
         const hash = hashUserKey(userKey);
 
         if (!userKeyHashes[hash]) {
@@ -379,7 +352,7 @@ export function pushManagerFactory(
           clients[userKey] = {
             hash64: hash64(userKey),
             worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
-            workerLarge: myLargeSegmentsSyncTask ? MySegmentsUpdateWorker(myLargeSegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT) : undefined
+            workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT)
           };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData } from './SSEHandler/types';
+import { IMySegmentsUpdateV3Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -11,8 +11,7 @@ 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 MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -22,24 +21,23 @@ export type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_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 | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE_V3 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
-  T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData :
-  T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data :
+  T extends MY_SEGMENTS_UPDATE_V3 ? IMySegmentsUpdateV3Data :
   T extends MY_LARGE_SEGMENTS_UPDATE ? IMyLargeSegmentsUpdateData :
   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;
 }
 
 /**
@@ -47,6 +45,6 @@ export interface IPushEventEmitter extends IEventEmitter {
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
   // Methods used in client-side, to support multiple clients
-  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask): void,
+  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void,
   remove(userKey: string): void
 }

package/src/sync/submitters/telemetrySubmitter.ts

@@ -76,12 +76,10 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
-        lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
         rR: {
           sp: scheduler.featuresRefreshRate / 1000,
           se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
           ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
-          mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
           im: scheduler.impressionsRefreshRate / 1000,
           ev: scheduler.eventsPushRate / 1000,
           te: scheduler.telemetryRefreshRate / 1000,

package/src/sync/submitters/types.ts

@@ -114,7 +114,7 @@ export type TOKEN = 'to';
 export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
 export type MY_LARGE_SEGMENT = 'mls';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT | MY_LARGE_SEGMENT;
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 
 export type LastSync = Partial<Record<OperationType, number | undefined>>
 export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
@@ -205,7 +205,6 @@ export type RefreshRates = {
   sp: number, // splits
   se?: number, // segments
   ms?: number, // mySegments
-  mls?: number, // myLargeSegments
   im: number, // impressions
   ev: number, // events
   te: number, // telemetry
@@ -231,7 +230,6 @@ export type TelemetryConfigStats = {
 // 'metrics/config' JSON request body
 export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   sE: boolean, // streamingEnabled
-  lE?: boolean, // largeSegmentsEnabled
   rR: RefreshRates, // refreshRates
   uO: UrlOverrides, // urlOverrides
   iQ: number, // impressionsQueueSize