@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

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

@@ -1,145 +0,0 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
-import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { ILogger } from '../../../logger/types';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
-import { ISplitsEventEmitter } from '../../../readiness/types';
-import { IRBSegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
-import { ITelemetryTracker } from '../../../trackers/types';
-import { Backoff } from '../../../utils/Backoff';
-import { SPLITS } from '../../../utils/constants';
-import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { InstantUpdate } from '../../polling/updaters/splitChangesUpdater';
-import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
-import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
-import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
-import { IUpdateWorker } from './types';
-
-/**
- * SplitsUpdateWorker factory
- */
-export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
-
-  const ff = SplitsUpdateWorker(storage.splits);
-  const rbs = SplitsUpdateWorker(storage.rbSegments);
-
-  function SplitsUpdateWorker(cache: ISplitsCacheSync | IRBSegmentsCacheSync) {
-    let maxChangeNumber = -1;
-    let handleNewEvent = false;
-    let isHandlingEvent: boolean;
-    let cdnBypass: boolean;
-    let instantUpdate: InstantUpdate | undefined;
-    const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-
-    function __handleSplitUpdateCall() {
-      isHandlingEvent = true;
-      if (maxChangeNumber > cache.getChangeNumber()) {
-        handleNewEvent = false;
-        // fetch splits revalidating data if cached
-        splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(() => {
-          if (!isHandlingEvent) return; // halt if `stop` has been called
-          if (handleNewEvent) {
-            __handleSplitUpdateCall();
-          } else {
-            if (instantUpdate) telemetryTracker.trackUpdatesFromSSE(SPLITS);
-            // fetch new registered segments for server-side API. Not retrying on error
-            if (segmentsSyncTask) segmentsSyncTask.execute(true);
-
-            const attempts = backoff.attempts + 1;
-
-            if (ff.isSync() && rbs.isSync()) {
-              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;
-              __handleSplitUpdateCall();
-            }
-          }
-        });
-      } else {
-        isHandlingEvent = false;
-      }
-    }
-
-    return {
-      /**
-       * Invoked by NotificationProcessor on SPLIT_UPDATE or RB_SEGMENT_UPDATE event
-       *
-       * @param changeNumber - change number of the notification
-       */
-      put({ changeNumber, pcn, type }: ISplitUpdateData, payload?: ISplit | IRBSegment) {
-        const currentChangeNumber = cache.getChangeNumber();
-
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
-
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-        instantUpdate = undefined;
-
-        if (payload && currentChangeNumber === pcn) {
-          instantUpdate = { payload, changeNumber, type };
-        }
-
-        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
-        backoff.reset();
-      },
-      stop() {
-        isHandlingEvent = false;
-        backoff.reset();
-      },
-      isSync() {
-        return maxChangeNumber <= cache.getChangeNumber();
-      }
-    };
-  }
-
-  return {
-    put(parsedData) {
-      if (parsedData.d && parsedData.c !== undefined) {
-        try {
-          const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
-          if (payload) {
-            (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
-            return;
-          }
-        } catch (e) {
-          log.warn(STREAMING_PARSING_SPLIT_UPDATE, [parsedData.type, e]);
-        }
-      }
-      (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData);
-    },
-    /**
-     * Invoked by NotificationProcessor on SPLIT_KILL event
-     *
-     * @param changeNumber - change number of the notification
-     * @param splitName - name of split to kill
-     * @param defaultTreatment - default treatment value
-     */
-    killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-      if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
-        // trigger an SDK_UPDATE if Split was killed locally
-        splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
-      }
-      // queues the SplitChanges fetch (only if changeNumber is newer)
-      ff.put({ changeNumber } as ISplitUpdateData);
-    },
-
-    stop() {
-      ff.stop();
-      rbs.stop();
-    }
-  };
-}

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

@@ -1,3 +0,0 @@
-export const FETCH_BACKOFF_BASE = 10000;  // backoff base starting at 10 seconds
-export const FETCH_BACKOFF_MAX_WAIT = 60000;  // don't wait for more than 1 minute
-export const FETCH_BACKOFF_MAX_RETRIES = 10; // max retries

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

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

package/src/sync/streaming/constants.ts

@@ -1,44 +0,0 @@
-// time for refresh token
-export const SECONDS_BEFORE_EXPIRATION = 600;
-
-// Internal SDK events, subscribed by SyncManager and PushManager
-/**
- * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
- * triggers `handleNonRetryableError` call
- */
-export const PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
-/**
- * emitted on SSE and Authenticate recoverable errors
- * triggers `handleRetryableError` call
- */
-export const PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
-/**
- * emitted on STREAMING_RESUMED control notification, OCCUPANCY different than 0, and SSE onopen event
- * triggers `stopPollingAndSyncAll` call
- */
-export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
-
-/**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
- * triggers `startPolling` and `stopWorkers` calls
- */
-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 SEGMENT_UPDATE = 'SEGMENT_UPDATE';
-export const SPLIT_KILL = 'SPLIT_KILL';
-export const SPLIT_UPDATE = 'SPLIT_UPDATE';
-export const RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
-
-// Control-type push notifications, handled by NotificationKeeper
-export const CONTROL = 'CONTROL';
-export const OCCUPANCY = 'OCCUPANCY';
-
-export enum ControlType {
-  STREAMING_DISABLED = 'STREAMING_DISABLED',
-  STREAMING_PAUSED = 'STREAMING_PAUSED',
-  STREAMING_RESUMED = 'STREAMING_RESUMED',
-  STREAMING_RESET = 'STREAMING_RESET',
-}

package/src/sync/streaming/parseUtils.ts

@@ -1,100 +0,0 @@
-import { algorithms } from '../../utils/decompress';
-import { decodeFromBase64 } from '../../utils/base64';
-import { hash } from '../../utils/murmur3/murmur3';
-import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
-import { IRBSegment, ISplit } from '../../dtos/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 data - base64 encoded string
- * @param compression - 1 GZIP, 2 ZLIB
- * @returns
- * @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 data - base64 encoded string
- * @param compression - 1 GZIP, 2 ZLIB
- * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns keyList
- * @throws if data string cannot be decoded, decompressed or parsed
- */
-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
-  if (avoidPrecisionLoss) strKeyList = strKeyList.replace(/\d+/g, '"$&"');
-  return JSON.parse(strKeyList);
-}
-
-/**
- * Decode, decompress and parse the provided 'data' into a Bitmap object
- *
- * @param data - base64 encoded string
- * @param compression - 1 GZIP, 2 ZLIB
- * @returns Bitmap
- * @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 bitmap - Uint8Array bitmap
- * @param hash64hex - 16-chars string, representing a number in hexa
- * @returns whether the provided 'hash64hex' index is set in the bitmap
- */
-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;
-}
-
-/**
- * Parse feature flags notifications for instant feature flag updates
- */
-export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | IRBSegment | undefined {
-  return compression > 0 ?
-    parseKeyList(data, compression, false) :
-    JSON.parse(decodeFromBase64(data));
-}
-
-const DEFAULT_MAX_INTERVAL = 60000;
-
-export function getDelay(parsedData: Pick<IMembershipMSUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
-  if (parsedData.h === 0) return 0;
-
-  const interval = parsedData.i || DEFAULT_MAX_INTERVAL;
-  const seed = parsedData.s || 0;
-
-  return hash(matchingKey, seed) % interval;
-}

package/src/sync/streaming/pushManager.ts

@@ -1,358 +0,0 @@
-import { IPushEventEmitter, IPushManager } from './types';
-import { ISSEClient } from './SSEClient/types';
-import { IMySegmentsSyncTask, IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { objectAssign } from '../../utils/lang/objectAssign';
-import { Backoff } from '../../utils/Backoff';
-import { SSEHandlerFactory } from './SSEHandler';
-import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
-import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
-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, RB_SEGMENT_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 } from '../../logger/constants';
-import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
-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';
-
-/**
- * PushManager factory:
- * - for server-side if key is not provided in settings.
- * - for client-side, with support for multiple clients, if key is provided in settings
- */
-export function pushManagerFactory(
-  params: ISdkFactoryContextSync,
-  pollingManager: IPollingManager,
-): IPushManager | undefined {
-
-  const { settings, storage, splitApi, readiness, platform, telemetryTracker } = params;
-
-  // `userKey` is the matching key of main client in client-side SDK.
-  // It can be used to check if running on client-side or server-side SDK.
-  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
-  const log = settings.log;
-
-  let sseClient: ISSEClient;
-  try {
-    // `useHeaders` false for client-side, even if the platform EventSource supports headers (e.g., React Native).
-    sseClient = new SSEClient(settings, platform);
-  } catch (e) {
-    log.warn(STREAMING_FALLBACK, [e]);
-    return;
-  }
-  const authenticate = authenticateFactory(splitApi.fetchAuth);
-
-  // init feedback loop
-  const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
-  const sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
-  sseClient.setEventHandler(sseHandler);
-
-  // init workers
-  // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-  const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
-  // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage, 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
-  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> }> = {};
-
-  // [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 `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.
-  // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
-  let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
-
-  /** PushManager functions related to initialization */
-
-  const connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
-
-  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);
-
-    // 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;
-
-    log.info(STREAMING_REFRESH_TOKEN, [refreshTokenDelay, connDelay]);
-
-    timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
-
-    timeoutIdSseOpen = setTimeout(() => {
-      // halt if disconnected
-      if (disconnected) return;
-      sseClient.open(authData);
-    }, connDelay * 1000);
-
-    telemetryTracker.streamingEvent(TOKEN_REFRESH, decodedToken.exp);
-  }
-
-  function connectPush() {
-    // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
-    if (disconnected) return;
-    // @TODO distinguish log for 'Connecting' (1st time) and 'Re-connecting'
-    log.info(STREAMING_CONNECTING);
-    disconnected = false;
-
-    const userKeys = userKey ? Object.keys(clients) : undefined;
-    authenticate(userKeys).then(
-      function (authData) {
-        if (disconnected) return;
-
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
-        // close the sseClient in case the org has been bloqued while the instance was connected to streaming
-        if (!authData.pushEnabled) {
-          log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // [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(clients).length) return;
-
-        // Schedule SSE connection and refresh token
-        scheduleTokenRefreshAndSse(authData);
-      }
-    ).catch(
-      function (error) {
-        if (disconnected) return;
-
-        log.error(ERROR_STREAMING_AUTH, [error.message]);
-
-        // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
-        if (error.statusCode >= 400 && error.statusCode < 500) {
-          telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // Handle other HTTP and network errors as recoverable errors
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      }
-    );
-  }
-
-  // close SSE connection and cancel scheduled tasks
-  function disconnectPush() {
-    // Halt disconnecting, just to avoid redundant logs if called multiple times
-    if (disconnected) return;
-    disconnected = true;
-
-    sseClient.close();
-    log.info(STREAMING_DISCONNECTING);
-
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
-    connectPushRetryBackoff.reset();
-
-    stopWorkers();
-  }
-
-  // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
-  function stopWorkers() {
-    splitsUpdateWorker.stop();
-    if (userKey) forOwn(clients, ({ worker }) => worker.stop());
-    else segmentsUpdateWorker!.stop();
-  }
-
-  pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
-
-  // 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();
-  });
-
-  /** Fallback to polling 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
-  });
-
-  /** Fallback to polling with retry due to recoverable SSE and Authentication errors */
-
-  pushEmitter.on(PUSH_RETRYABLE_ERROR, function handleRetryableError() { // HTTP or network error in SSE connection
-    // SSE connection is closed to avoid repeated errors due to retries
-    sseClient.close();
-
-    // retry streaming reconnect with backoff algorithm
-    let delayInMillis = connectPushRetryBackoff.scheduleCall();
-
-    log.info(STREAMING_RECONNECT, [delayInMillis / 1000]);
-
-    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);
-  pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
-
-  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;
-      }
-      case UpdateStrategy.KeyList: {
-        let keyList: KeyList, added: Set<string>, removed: Set<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;
-        }
-
-        if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
-          break;
-        }
-
-        forOwn(clients, ({ hash64, worker }) => {
-          const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
-          if (add !== undefined) {
-            worker.put(parsedData, {
-              added: add ? [parsedData.n![0]] : [],
-              removed: add ? [] : [parsedData.n![0]]
-            });
-          }
-        });
-        return;
-      }
-      case UpdateStrategy.SegmentRemoval:
-        if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
-          break;
-        }
-
-        forOwn(clients, ({ worker }) => {
-          worker.put(parsedData, {
-            added: [],
-            removed: parsedData.n!
-          });
-        });
-        return;
-    }
-
-    // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-    forOwn(clients, ({ worker }, matchingKey) => {
-      worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
-    });
-  }
-
-  if (userKey) {
-    pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
-    pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
-  } else {
-    pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
-  }
-
-  return objectAssign(
-    // Expose Event Emitter functionality and Event constants
-    Object.create(pushEmitter),
-    {
-      // Stop/pause push mode.
-      // It doesn't emit events. Neither PUSH_SUBSYSTEM_DOWN to start polling.
-      stop() {
-        disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
-        if (userKey) this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
-      },
-
-      // Start/resume push mode.
-      // It eventually emits PUSH_SUBSYSTEM_DOWN, that starts polling, or PUSH_SUBSYSTEM_UP, that executes a syncAll
-      start() {
-        // 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;
-
-        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
-      },
-
-      // true/false if start or stop was called last respectively
-      isRunning() {
-        return disconnected === false;
-      },
-
-      // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
-        const hash = hashUserKey(userKey);
-
-        if (!userKeyHashes[hash]) {
-          userKeyHashes[hash] = userKey;
-          clients[userKey] = {
-            hash64: hash64(userKey),
-            worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
-          };
-          connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
-
-          // Reconnects in case of a new client.
-          // Run in next event-loop cycle to save authentication calls
-          // in case multiple clients are created in the current cycle.
-          if (this.isRunning()) {
-            setTimeout(function checkForReconnect() {
-              if (connectForNewClient) {
-                connectForNewClient = false;
-                connectPush();
-              }
-            }, 0);
-          }
-        }
-      },
-      // [Only for client-side]
-      remove(userKey: string) {
-        const hash = hashUserKey(userKey);
-        delete userKeyHashes[hash];
-        delete clients[userKey];
-      }
-    }
-  );
-}