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

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

@@ -3,81 +3,129 @@ import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { MEMBERSHIPS } from '../../../utils/constants';
+import { ISegmentsCacheSync, IStorageSync } from '../../../storages/types';
+import { ILogger } from '../../../logger/types';
+import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
-
-  let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-  let currentChangeNumber = -1;
-  let handleNewEvent = false;
-  let isHandlingEvent: boolean;
-  let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-  let _delay: undefined | number;
-  let _delayTimeoutID: any;
-  const backoff = new Backoff(__handleMySegmentsUpdateCall);
-
-  function __handleMySegmentsUpdateCall() {
-    isHandlingEvent = true;
-    if (maxChangeNumber > currentChangeNumber) {
-      handleNewEvent = false;
-      const currentMaxChangeNumber = maxChangeNumber;
-
-      // fetch mySegments revalidating data if cached
-      const syncTask = _delay ?
-        new Promise(res => {
-          _delayTimeoutID = setTimeout(() => {
-            _delay = undefined;
-            mySegmentsSyncTask.execute(_segmentsData, true).then(res);
-          }, _delay);
-        }) :
-        mySegmentsSyncTask.execute(_segmentsData, true);
-
-      syncTask.then((result) => {
-        if (!isHandlingEvent) return; // halt if `stop` has been called
-        if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
-          currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-        }
-        if (handleNewEvent) {
-          __handleMySegmentsUpdateCall();
-        } else {
-          backoff.scheduleCall();
-        }
-      });
-    } else {
-      isHandlingEvent = false;
+export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
+
+  function createUpdateWorker(mySegmentsCache: ISegmentsCacheSync) {
+
+    let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+    let currentChangeNumber = -1;
+    let handleNewEvent = false;
+    let isHandlingEvent: boolean;
+    let cdnBypass: boolean;
+    let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+    let _delay: undefined | number;
+    let _delayTimeoutID: any;
+    const backoff = new Backoff(__handleMySegmentsUpdateCall);
+
+    function __handleMySegmentsUpdateCall() {
+      isHandlingEvent = true;
+      if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
+        handleNewEvent = false;
+        const currentMaxChangeNumber = maxChangeNumber;
+
+        // fetch mySegments revalidating data if cached
+        const syncTask = _delay ?
+          new Promise(res => {
+            _delayTimeoutID = setTimeout(() => {
+              _delay = undefined;
+              mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
+            }, _delay);
+          }) :
+          mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
+
+        syncTask.then((result) => {
+          if (!isHandlingEvent) return; // halt if `stop` has been called
+          if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
+            const storageChangeNumber = mySegmentsCache.getChangeNumber();
+            currentChangeNumber = storageChangeNumber > -1 ?
+              storageChangeNumber :
+              Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+          }
+          if (handleNewEvent) {
+            __handleMySegmentsUpdateCall();
+          } else {
+            if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
+
+            const attempts = backoff.attempts + 1;
+
+            if (maxChangeNumber <= currentChangeNumber) {
+              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+              isHandlingEvent = false;
+              return;
+            }
+
+            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+              backoff.scheduleCall();
+              return;
+            }
+
+            if (cdnBypass) {
+              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
+              isHandlingEvent = false;
+            } else {
+              backoff.reset();
+              cdnBypass = true;
+              __handleMySegmentsUpdateCall();
+            }
+          }
+        });
+      } else {
+        isHandlingEvent = false;
+      }
     }
+
+    return {
+      /**
+       * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+       *
+       * @param changeNumber change number of the notification
+       * @param segmentsData data for KeyList or SegmentRemoval instant updates
+       * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
+       */
+      put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
+        const { type, cn } = mySegmentsData;
+        // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+        if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber || _delay) return;
+
+        maxChangeNumber = cn;
+        handleNewEvent = true;
+        cdnBypass = false;
+        _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
+        _delay = delay;
+
+        if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
+        backoff.reset();
+      },
+
+      stop() {
+        clearTimeout(_delayTimeoutID);
+        _delay = undefined;
+        isHandlingEvent = false;
+        backoff.reset();
+      }
+    };
   }
 
+  const updateWorkers = {
+    [MEMBERSHIPS_MS_UPDATE]: createUpdateWorker(storage.segments),
+    [MEMBERSHIPS_LS_UPDATE]: createUpdateWorker(storage.largeSegments!),
+  };
+
   return {
-    /**
-     * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
-     *
-     * @param changeNumber change number of the notification
-     * @param segmentsData data for KeyList or SegmentRemoval instant updates
-     * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
-     */
     put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
-      const { type, cn } = mySegmentsData;
-      // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-      if (cn <= currentChangeNumber || cn <= maxChangeNumber || _delay) return;
-
-      maxChangeNumber = cn;
-      handleNewEvent = true;
-      _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
-      _delay = delay;
-
-      if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
-      backoff.reset();
+      updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
     },
-
     stop() {
-      clearTimeout(_delayTimeoutID);
-      _delay = undefined;
-      isHandlingEvent = false;
-      backoff.reset();
+      updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
+      updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
     }
   };
 }

package/src/sync/streaming/constants.ts

@@ -25,8 +25,8 @@ export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 
 // Update-type push notifications, handled by NotificationProcessor
-export const MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
-export const MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
+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';

package/src/sync/streaming/pushManager.ts

@@ -11,8 +11,8 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIP_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
@@ -63,7 +63,7 @@ export function pushManagerFactory(
   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>, workerLarge: ReturnType<typeof 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;
@@ -170,10 +170,7 @@ export function pushManagerFactory(
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
     splitsUpdateWorker.stop();
-    if (userKey) forOwn(clients, ({ worker, workerLarge }) => {
-      worker.stop();
-      workerLarge.stop();
-    });
+    if (userKey) forOwn(clients, ({ worker }) => worker.stop());
     else segmentsUpdateWorker!.stop();
   }
 
@@ -239,21 +236,19 @@ export function pushManagerFactory(
   });
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
-    const isLS = parsedData.type === MEMBERSHIP_LS_UPDATE;
-
     switch (parsedData.u) {
       case UpdateStrategy.BoundedFetchRequest: {
         let bitmap: Uint8Array;
         try {
           bitmap = parseBitmap(parsedData.d!, parsedData.c!);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['BoundedFetchRequest', e]);
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['BoundedFetchRequest', e]);
           break;
         }
 
-        forOwn(clients, ({ hash64, worker, workerLarge }, matchingKey) => {
+        forOwn(clients, ({ hash64, worker }, matchingKey) => {
           if (isInBitmap(bitmap, hash64.hex)) {
-            (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
+            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
           }
         });
         return;
@@ -265,19 +260,19 @@ export function pushManagerFactory(
           added = new _Set(keyList.a);
           removed = new _Set(keyList.r);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', e]);
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);
           break;
         }
 
         if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', 'No segment name was provided']);
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
           break;
         }
 
-        forOwn(clients, ({ hash64, worker, workerLarge }) => {
+        forOwn(clients, ({ hash64, worker }) => {
           const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
           if (add !== undefined) {
-            (isLS ? workerLarge : worker).put(parsedData, {
+            worker.put(parsedData, {
               added: add ? [parsedData.n![0]] : [],
               removed: add ? [] : [parsedData.n![0]]
             });
@@ -287,12 +282,12 @@ export function pushManagerFactory(
       }
       case UpdateStrategy.SegmentRemoval:
         if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+          log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
           break;
         }
 
-        forOwn(clients, ({ worker, workerLarge }) => {
-          (isLS ? workerLarge : worker).put(parsedData, {
+        forOwn(clients, ({ worker }) => {
+          worker.put(parsedData, {
             added: [],
             removed: parsedData.n!
           });
@@ -301,14 +296,14 @@ export function pushManagerFactory(
     }
 
     // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-    forOwn(clients, ({ worker, workerLarge }, matchingKey) => {
-      (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
+    forOwn(clients, ({ worker }, matchingKey) => {
+      worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
     });
   }
 
   if (userKey) {
-    pushEmitter.on(MEMBERSHIP_MS_UPDATE, handleMySegmentsUpdate);
-    pushEmitter.on(MEMBERSHIP_LS_UPDATE, handleMySegmentsUpdate);
+    pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
+    pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
@@ -348,8 +343,7 @@ export function pushManagerFactory(
           userKeyHashes[hash] = userKey;
           clients[userKey] = {
             hash64: hash64(userKey),
-            worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker),
-            workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker)
+            worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
           };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 

package/src/sync/streaming/types.ts

@@ -11,8 +11,8 @@ export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
-export type MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
-export type MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
+export type MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -21,11 +21,11 @@ export type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
-  T extends MEMBERSHIP_MS_UPDATE ? IMembershipMSUpdateData :
-  T extends MEMBERSHIP_LS_UPDATE ? IMembershipLSUpdateData :
+  T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
+  T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;

package/src/sync/submitters/types.ts

@@ -176,7 +176,7 @@ export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   spC?: number, // splitCount
   seC?: number, // segmentCount
   skC?: number, // segmentKeyCount
-  lseC?: number, // largeSegmentCount
+  lsC?: number, // largeSegmentCount
   lskC?: number, // largeSegmentKeyCount
   sL?: number, // sessionLengthMs
   eQ: number, // eventsQueued

package/types/logger/constants.d.ts

@@ -77,7 +77,7 @@ export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
-export declare const STREAMING_PARSING_MEMBERSHIP_UPDATE = 223;
+export declare const STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export declare const WARN_INVALID_FLAGSET = 225;
 export declare const WARN_LOWERCASE_FLAGSET = 226;

package/types/services/types.d.ts

@@ -18,7 +18,7 @@ export declare type ISplitHttpClient = (url: string, options?: IRequestOptions,
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
-export declare type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
+export declare type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;

package/types/storages/types.d.ts

@@ -247,7 +247,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
     getRegisteredSegments(): string[];
     getKeysCount(): number;
     setChangeNumber(name: string, changeNumber: number): boolean | void;
-    getChangeNumber(name: string): number;
+    getChangeNumber(name?: string): number;
     resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
     clear(): void;
 }

package/types/sync/polling/fetchers/types.d.ts

@@ -2,4 +2,4 @@ import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse }
 import { IResponse } from '../../../services/types';
 export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
 export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
-export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<IMembershipsResponse>;
+export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<IMembershipsResponse>;

package/types/sync/polling/types.d.ts

@@ -1,7 +1,7 @@
 import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../streaming/types';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: {
     payload: ISplit;
@@ -11,12 +11,12 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
 }
 export declare type MySegmentsData = {
-    type: MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE;
+    type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE;
     cn: number;
     added: string[];
     removed: string[];
 };
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;

package/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -3,7 +3,7 @@ import { IStorageSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
 import { MySegmentsData } from '../types';
-declare type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>;
+declare type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 export declare enum Compression {
     None = 0,
     Gzip = 1,
@@ -26,9 +26,9 @@ interface IMembershipUpdateData<T extends string> {
     h?: number;
     s?: number;
 }
-export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIP_MS_UPDATE> {
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> {
 }
-export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIP_LS_UPDATE> {
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> {
 }
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,7 +1,9 @@
 import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
+import { IStorageSync } from '../../../storages/types';
+import { ILogger } from '../../../logger/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]>;
+export declare function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]>;

package/types/sync/streaming/constants.d.ts

@@ -19,8 +19,8 @@ export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
  * triggers `startPolling` and `stopWorkers` calls
  */
 export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
-export declare const MEMBERSHIP_MS_UPDATE = "MEMBERSHIP_MS_UPDATE";
-export declare const MEMBERSHIP_LS_UPDATE = "MEMBERSHIP_LS_UPDATE";
+export declare const MEMBERSHIPS_MS_UPDATE = "MEMBERSHIPS_MS_UPDATE";
+export declare const MEMBERSHIPS_LS_UPDATE = "MEMBERSHIPS_LS_UPDATE";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";

package/types/sync/streaming/types.d.ts

@@ -7,15 +7,15 @@ export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 export declare type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
 export declare type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
-export declare type MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
-export declare type MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
+export declare type MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export declare type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export declare type SPLIT_KILL = 'SPLIT_KILL';
 export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
 export declare type CONTROL = 'CONTROL';
 export declare type OCCUPANCY = 'OCCUPANCY';
-export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
-declare type IParsedData<T extends IPushEvent> = T extends MEMBERSHIP_MS_UPDATE ? IMembershipMSUpdateData : T extends MEMBERSHIP_LS_UPDATE ? IMembershipLSUpdateData : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : INotificationData;
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData : T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : 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

package/types/sync/submitters/types.d.ts

@@ -152,7 +152,7 @@ export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     spC?: number;
     seC?: number;
     skC?: number;
-    lseC?: number;
+    lsC?: number;
     lskC?: number;
     sL?: number;
     eQ: number;