@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

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, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { INotificationError } 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';
 
@@ -43,7 +43,7 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE
         log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);
       }
 
-      let errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
+      let errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
       log.error(ERROR_STREAMING_SSE, [errorMessage]);
 
       if (isRetryableError(errorWithParsedData)) {
@@ -55,9 +55,10 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE
 
     /* NotificationProcessor */
     handleMessage(message) {
-      let messageWithParsedData;
+      let messageWithParsedData: INotificationMessage | undefined;
       try {
         messageWithParsedData = messageParser(message);
+        if (!messageWithParsedData) return; // Messages with empty data are ignored
       } catch (err) {
         log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);
         return;
@@ -67,30 +68,19 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
       // we only handle update events if streaming is up.
-      if (!notificationKeeper.isStreamingUp() && parsedData.type !== OCCUPANCY && parsedData.type !== CONTROL)
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
         return;
 
       switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
-          pushEmitter.emit(SPLIT_UPDATE,
-            parsedData.changeNumber);
-          break;
         case SEGMENT_UPDATE:
-          pushEmitter.emit(SEGMENT_UPDATE,
-            parsedData.changeNumber,
-            parsedData.segmentName);
+        case MY_SEGMENTS_UPDATE_V2:
+        case SPLIT_KILL:
+          pushEmitter.emit(parsedData.type, parsedData);
           break;
         case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(MY_SEGMENTS_UPDATE,
-            parsedData,
-            channel);
-          break;
-        case SPLIT_KILL:
-          pushEmitter.emit(SPLIT_KILL,
-            parsedData.changeNumber,
-            parsedData.splitName,
-            parsedData.defaultTreatment);
+          pushEmitter.emit(parsedData.type, parsedData, channel);
           break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
@@ -100,6 +90,7 @@ export default function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventE
         case CONTROL:
           notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
           break;
+
         default:
           break;
       }

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
 
 export interface IMySegmentsUpdateData {
   type: MY_SEGMENTS_UPDATE,
@@ -8,6 +8,33 @@ export interface IMySegmentsUpdateData {
   segmentList?: string[]
 }
 
+export enum Compression {
+  None = 0,
+  Gzip = 1,
+  Zlib = 2
+}
+
+export enum UpdateStrategy {
+  UnboundedFetchRequest = 0,
+  BoundedFetchRequest = 1,
+  KeyList = 2,
+  SegmentRemoval = 3
+}
+
+export interface KeyList {
+  a?: string[], // decimal hash64 of user keys
+  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 ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -38,6 +65,13 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | 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 }
+export type INotificationError = Event & { parsedData?: any, message?: string }
+
+export type SegmentsData = string[] | {
+  /* segment name */
+  name: string,
+  /* action: `true` for add, and `false` for delete */
+  add: boolean
+}

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

@@ -1,6 +1,7 @@
 import { ISegmentsSyncTask } from '../../polling/types';
 import Backoff from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
+import { SegmentsData } from '../SSEHandler/types';
 
 /**
  * MySegmentsUpdateWorker class
@@ -10,7 +11,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
   private readonly mySegmentsSyncTask: ISegmentsSyncTask;
   private maxChangeNumber: number;
   private handleNewEvent: boolean;
-  private segmentList?: string[];
+  private segmentsData?: SegmentsData;
   private currentChangeNumber: number;
   readonly backoff: Backoff;
 
@@ -21,7 +22,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
     this.mySegmentsSyncTask = mySegmentsSyncTask;
     this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     this.handleNewEvent = false;
-    this.segmentList = undefined; // keeps the segmentList (if included in payload) from the queued event with maximum changeNumber
+    this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
     this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
     this.put = this.put.bind(this);
     this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
@@ -36,7 +37,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
       const currentMaxChangeNumber = this.maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      this.mySegmentsSyncTask.execute(this.segmentList, true).then((result) => {
+      this.mySegmentsSyncTask.execute(this.segmentsData, true).then((result) => {
         if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
           this.currentChangeNumber = Math.max(this.currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
         if (this.handleNewEvent) {
@@ -52,15 +53,15 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
    * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
    *
    * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-   * @param {string[] | undefined} segmentList might be undefined
+   * @param {SegmentsData | undefined} segmentsData might be undefined
    */
-  put(changeNumber: number, segmentList?: string[]) {
+  put(changeNumber: number, segmentsData?: SegmentsData) {
     if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
 
     this.maxChangeNumber = changeNumber;
     this.handleNewEvent = true;
     this.backoff.reset();
-    this.segmentList = segmentList;
+    this.segmentsData = segmentsData;
 
     if (this.mySegmentsSyncTask.isExecuting()) return;
 

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

@@ -1,6 +1,7 @@
 import { ISegmentsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 
 /**
@@ -66,7 +67,7 @@ export default class SegmentsUpdateWorker implements IUpdateWorker {
    * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
    * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
    */
-  put(changeNumber: number, segmentName: string) {
+  put({ changeNumber, segmentName }: ISegmentUpdateData) {
     const currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
 
     if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName]) return;

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

@@ -3,6 +3,7 @@ import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 
 /**
@@ -60,7 +61,7 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
    *
    * @param {number} changeNumber change number of the SPLIT_UPDATE notification
    */
-  put(changeNumber: number) {
+  put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
     const currentChangeNumber = this.splitsCache.getChangeNumber();
 
     if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
@@ -81,14 +82,14 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
    * @param {string} splitName name of split to kill
    * @param {string} defaultTreatment default treatment value
    */
-  killSplit(changeNumber: number, splitName: string, defaultTreatment: string) {
+  killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
     // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
     if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
       // trigger an SDK_UPDATE if Split was killed locally
       this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
     }
     // queues the SplitChanges fetch (only if changeNumber is newer)
-    this.put(changeNumber);
+    this.put({ changeNumber });
   }
 
 }

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

@@ -2,5 +2,5 @@ import Backoff from '../../../utils/Backoff';
 
 export interface IUpdateWorker {
   readonly backoff: Backoff,
-  put(changeNumber: number, ...args: any[]): void
+  put(...args: any[]): void
 }

package/src/sync/streaming/constants.ts

@@ -26,6 +26,7 @@ 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 SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -38,4 +39,5 @@ export enum ControlType {
   STREAMING_DISABLED = 'STREAMING_DISABLED',
   STREAMING_PAUSED = 'STREAMING_PAUSED',
   STREAMING_RESUMED = 'STREAMING_RESUMED',
+  STREAMING_RESET = 'STREAMING_RESET',
 }

package/src/sync/streaming/mySegmentsV2utils.ts

@@ -0,0 +1,77 @@
+import { algorithms } from '../../utils/decompress';
+import { decodeFromBase64 } from '../../utils/base64';
+import { Compression, KeyList } from './SSEHandler/types';
+
+const GZIP = 1;
+const ZLIB = 2;
+
+function Uint8ArrayToString(myUint8Arr: Uint8Array) { // @ts-ignore
+  return String.fromCharCode.apply(null, myUint8Arr);
+}
+
+function StringToUint8Array(myString: string) {
+  const charCodes = myString.split('').map((e) => e.charCodeAt(0));
+  return new Uint8Array(charCodes);
+}
+
+/**
+ * Decode and decompress 'data' with 'compression' algorithm
+ *
+ * @param {string} data
+ * @param {number} compression 1 GZIP, 2 ZLIB
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
+ */
+function decompress(data: string, compression: Compression) {
+  let compressData = decodeFromBase64(data);
+  const binData = StringToUint8Array(compressData);
+
+  if (typeof algorithms === 'string') throw new Error(algorithms);
+  if (compression === GZIP) return algorithms.gunzipSync(binData);
+  if (compression === ZLIB) return algorithms.unzlibSync(binData);
+  throw new Error(`Invalid compression algorithm #${compression}`);
+}
+
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+export function parseKeyList(data: string, compression: Compression): KeyList {
+  const binKeyList = decompress(data, compression);
+  const strKeyList = Uint8ArrayToString(binKeyList);
+
+  // replace numbers to strings, to avoid losing precision
+  return JSON.parse(strKeyList.replace(/\d+/g, '"$&"'));
+}
+
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+export function parseBitmap(data: string, compression: Compression) {
+  return decompress(data, compression);
+}
+
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
+  // using the lowest 32 bits as index, to avoid losing precision when converting to number
+  const index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
+
+  const internal = Math.floor(index / 8);
+  const offset = index % 8;
+  return (bitmap[internal] & 1 << offset) > 0;
+}

package/src/sync/streaming/pushManager.ts

@@ -3,7 +3,6 @@ import { ISSEClient } from './SSEClient/types';
 import { IStorageSync } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
-import { IUpdateWorker } from './UpdateWorkers/types';
 import objectAssign from 'object-assign';
 import Backoff from '../../utils/Backoff';
 import SSEHandlerFactory from './SSEHandler';
@@ -16,9 +15,14 @@ import SSEClient from './SSEClient';
 import { IFetchAuth } from '../../services/types';
 import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP } from './constants';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { IPlatform } from '../../sdkFactory/types';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT } from '../../logger/constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
+import { KeyList, UpdateStrategy } from './SSEHandler/types';
+import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
+import { ISet, _Set } from '../../utils/lang/sets';
+import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
+import { IAuthTokenPushEnabled } from './AuthClient/types';
 
 /**
  * PushManager factory:
@@ -54,53 +58,67 @@ export default function pushManagerFactory(
   const sseHandler = SSEHandlerFactory(log, pushEmitter);
   sseClient.setEventHandler(sseHandler);
 
+  // init workers
+  const segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+  // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
+  const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+
   // [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: MySegmentsUpdateWorker }> = {};
   if (userKey) {
     const hash = hashUserKey(userKey);
     userKeyHashes[hash] = userKey;
+    clients[userKey] = { hash64: hash64(userKey), worker: segmentsUpdateWorker as MySegmentsUpdateWorker };
   }
 
-  // init workers
-  const segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
-  // [Only for server-side] we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
-  // [Only for client-side] map of user keys to their corresponding MySegmentsUpdateWorkers. It has a two-fold intention:
-  // - stop workers all together when push is disconnected
-  // - keep the current list of user keys to authenticate
-  const workers: Record<string, IUpdateWorker> = {};
-  if (userKey) workers[userKey] = segmentsUpdateWorker;
-
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
 
-  // flag that indicates if `disconnectPush` was called, either by the SyncManager (when the client is destroyed) or by a PUSH_NONRETRYABLE_ERROR error.
+  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
   // It is used to halt the `connectPush` process if it was in progress.
   let disconnected: boolean | undefined;
+  // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+  let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
 
   /** PushManager functions related to initialization */
 
   const connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
 
-  let timeoutId: ReturnType<typeof setTimeout>;
+  let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
+  let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
+
+  function scheduleTokenRefreshAndSse(authData: IAuthTokenPushEnabled) {
+    // clear scheduled tasks if exist
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
 
-  function scheduleTokenRefresh(issuedAt: number, expirationTime: number) {
-    // clear scheduled token refresh if exists (needed when resuming PUSH)
-    if (timeoutId) clearTimeout(timeoutId);
+    // Set token refresh 10 minutes before `expirationTime - issuedAt`
+    const decodedToken = authData.decodedToken;
+    const refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION;
+    // Default connDelay of 60 secs
+    const connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
 
-    // Set token refresh 10 minutes before expirationTime
-    const delayInSeconds = expirationTime - issuedAt - SECONDS_BEFORE_EXPIRATION;
+    log.info(STREAMING_REFRESH_TOKEN, [refreshTokenDelay, connDelay]);
 
-    log.info(STREAMING_REFRESH_TOKEN, [delayInSeconds]);
+    timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
 
-    timeoutId = setTimeout(connectPush, delayInSeconds * 1000);
+    timeoutIdSseOpen = setTimeout(() => {
+      // halt if disconnected
+      if (disconnected) return;
+      sseClient.open(authData);
+    }, connDelay * 1000);
   }
 
   function connectPush() {
+    // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
+    if (disconnected) return;
+    log.info(STREAMING_CONNECTING, [disconnected === undefined ? '' : 'Re-']);
     disconnected = false;
-    log.info(STREAMING_CONNECTING);
 
-    const userKeys = userKey ? Object.keys(workers) : undefined;
+    const userKeys = userKey ? Object.keys(clients) : undefined;
     authenticate(userKeys).then(
       function (authData) {
         if (disconnected) return;
@@ -114,12 +132,10 @@ export default function pushManagerFactory(
         }
 
         // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
-        if (userKeys && userKeys.length < Object.keys(workers).length) return;
+        if (userKeys && userKeys.length < Object.keys(clients).length) return;
 
-        // Connect to SSE and schedule refresh token
-        const decodedToken = authData.decodedToken;
-        sseClient.open(authData);
-        scheduleTokenRefresh(decodedToken.iat, decodedToken.exp);
+        // Schedule SSE connection and refresh token
+        scheduleTokenRefreshAndSse(authData);
       }
     ).catch(
       function (error) {
@@ -141,11 +157,15 @@ export default function pushManagerFactory(
 
   // close SSE connection and cancel scheduled tasks
   function disconnectPush() {
-    sseClient.close();
+    // Halt disconnecting, just to avoid redundant logs if called multiple times
+    if (disconnected) return;
     disconnected = true;
+
+    sseClient.close();
     log.info(STREAMING_DISCONNECTING);
 
-    if (timeoutId) clearTimeout(timeoutId);
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
     connectPushRetryBackoff.reset();
 
     stopWorkers();
@@ -154,18 +174,23 @@ export default function pushManagerFactory(
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
     splitsUpdateWorker.backoff.reset();
-    if (userKey) forOwn(workers, worker => worker.backoff.reset());
+    if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
     else segmentsUpdateWorker.backoff.reset();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
 
-  // restart backoff retry counter once push is connected
-  pushEmitter.on(PUSH_SUBSYSTEM_UP, () => { connectPushRetryBackoff.reset(); });
+  // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
+  // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
+  pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
+    connectPushRetryBackoff.reset();
+    stopWorkers();
+  });
 
   /** Fallbacking without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
 
   pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    disabled = true;
     // Note: `stopWorkers` is been called twice, but it is not harmful
     disconnectPush();
     pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
@@ -185,21 +210,93 @@ export default function pushManagerFactory(
     pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
   });
 
+  /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */
+
+  pushEmitter.on(ControlType.STREAMING_RESET, function handleStreamingReset() {
+    if (disconnected) return; // should never happen
+
+    // Minimum required clean-up.
+    // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+
+    connectPush();
+  });
+
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
   pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
   pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
+
   if (userKey) {
     pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
       const userKeyHash = channel.split('_')[2];
       const userKey = userKeyHashes[userKeyHash];
-      if (userKey && workers[userKey]) { // check context since it can be undefined if client has been destroyed
-        const mySegmentsUpdateWorker = workers[userKey];
-        mySegmentsUpdateWorker.put(
+      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;
+        }
+        case UpdateStrategy.KeyList: {
+          let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
+          try {
+            keyList = parseKeyList(parsedData.d, parsedData.c);
+            added = new _Set(keyList.a);
+            removed = new _Set(keyList.r);
+          } catch (e) {
+            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+            break;
+          }
+
+          forOwn(clients, ({ hash64, worker }) => {
+            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+            if (add !== undefined) {
+              worker.put(parsedData.changeNumber, {
+                name: parsedData.segmentName,
+                add
+              });
+            }
+          });
+          return;
+        }
+        case UpdateStrategy.SegmentRemoval:
+          if (!parsedData.segmentName) {
+            log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+            break;
+          }
+
+          forOwn(clients, ({ worker }) =>
+            worker.put(parsedData.changeNumber, {
+              name: parsedData.segmentName,
+              add: false
+            })
+          );
+          return;
+      }
+
+      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+      forOwn(clients, ({ worker }) => {
+        worker.put(parsedData.changeNumber);
+      });
+    });
   } else {
     pushEmitter.on(SEGMENT_UPDATE, (segmentsUpdateWorker as SegmentsUpdateWorker).put);
   }
@@ -209,11 +306,11 @@ export default function pushManagerFactory(
     Object.create(pushEmitter),
     {
       // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which start polling.
+      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
 
       start() {
-        // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times.
-        if (disconnected === false) return;
+        // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
+        if (disabled || disconnected === false) return;
         disconnected = false;
         // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
         setTimeout(connectPush);
@@ -221,8 +318,7 @@ export default function pushManagerFactory(
 
       // [Only for client-side]
       add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
-        const mySegmentsUpdateWorker = new MySegmentsUpdateWorker(mySegmentsSyncTask);
-        workers[userKey] = mySegmentsUpdateWorker;
+        clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
 
         const hash = hashUserKey(userKey);
 
@@ -245,6 +341,7 @@ export default function pushManagerFactory(
       remove(userKey: string) {
         const hash = hashUserKey(userKey);
         delete userKeyHashes[hash];
+        delete clients[userKey];
       }
     }
   );