@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.0

package/src/storages/types.ts

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
+import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { ISettings } from '../types';
@@ -177,11 +177,9 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
-  removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): MaybeThenable<boolean>,
   getSplit(name: string): MaybeThenable<ISplit | null>,
   getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
-  setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
   getAll(): MaybeThenable<ISplit[]>,
@@ -198,11 +196,9 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): boolean[],
-  removeSplits(names: string[]): boolean[],
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean,
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -215,11 +211,9 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
-  removeSplits(names: string[]): Promise<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean>,
   getSplit(name: string): Promise<ISplit | null>,
   getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
-  setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
   getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
@@ -231,6 +225,34 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
 
+/** Rule-Based Segments cache */
+
+export interface IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): MaybeThenable<boolean>,
+  get(name: string): MaybeThenable<IRBSegment | null>,
+  getChangeNumber(): MaybeThenable<number>,
+  clear(): MaybeThenable<boolean | void>,
+  contains(names: Set<string>): MaybeThenable<boolean>,
+}
+
+export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean,
+  get(name: string): IRBSegment | null,
+  getChangeNumber(): number,
+  clear(): void,
+  contains(names: Set<string>): boolean,
+  // Used only for smart pausing in client-side standalone. Returns true if the storage contains a RBSegment using segments or large segments matchers
+  usesSegments(): boolean,
+}
+
+export interface IRBSegmentsCacheAsync extends IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean>,
+  get(name: string): Promise<IRBSegment | null>,
+  getChangeNumber(): Promise<number>,
+  clear(): Promise<boolean | void>,
+  contains(names: Set<string>): Promise<boolean>,
+}
+
 /** Segments cache */
 
 export interface ISegmentsCacheBase {
@@ -428,15 +450,17 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
  */
 
 export interface IStorageBase<
-  TSplitsCache extends ISplitsCacheBase,
-  TSegmentsCache extends ISegmentsCacheBase,
-  TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheBase,
-  TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
-  TUniqueKeysCache extends IUniqueKeysCacheBase
+  TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
+  TRBSegmentsCache extends IRBSegmentsCacheBase = IRBSegmentsCacheBase,
+  TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
+  TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheBase = IImpressionCountsCacheBase,
+  TEventsCache extends IEventsCacheBase = IEventsCacheBase,
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync = ITelemetryCacheSync | ITelemetryCacheAsync,
+  TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
   splits: TSplitsCache,
+  rbSegments: TRBSegmentsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
   impressionCounts: TImpressionsCountCache,
@@ -449,6 +473,7 @@ export interface IStorageBase<
 
 export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
+  IRBSegmentsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
   IImpressionCountsCacheSync,
@@ -462,6 +487,7 @@ export interface IStorageSync extends IStorageBase<
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
+  IRBSegmentsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
   IImpressionCountsCacheBase,

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, ISplit][] = [];
+    const splits: ISplit[] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -37,24 +37,23 @@ export function fromObjectUpdaterFactory(
     if (!loadError && splitsMock) {
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
-      forOwn(splitsMock, function (val, name) {
-        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-          name, {
-            name,
-            status: 'ACTIVE',
-            killed: false,
-            trafficAllocation: 100,
-            defaultTreatment: CONTROL,
-            conditions: val.conditions || [],
-            configurations: val.configurations,
-            trafficTypeName: val.trafficTypeName
-          }
-        ]);
+      forOwn(splitsMock, (val, name) => {
+        // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+        splits.push({
+          name,
+          status: 'ACTIVE',
+          killed: false,
+          trafficAllocation: 100,
+          defaultTreatment: CONTROL,
+          conditions: val.conditions || [],
+          configurations: val.configurations,
+          trafficTypeName: val.trafficTypeName
+        });
       });
 
       return Promise.all([
         splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.addSplits(splits)
+        splitsCache.update(splits, [], Date.now())
       ]).then(() => {
         readiness.splits.emit(SDK_SPLITS_ARRIVED);
 

package/src/sync/polling/fetchers/splitChangesFetcher.ts

@@ -11,11 +11,12 @@ export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges
     since: number,
     noCache?: boolean,
     till?: number,
+    rbSince?: number,
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ) {
 
-    let splitsPromise = fetchSplitChanges(since, noCache, till);
+    let splitsPromise = fetchSplitChanges(since, noCache, till, rbSince);
     if (decorator) splitsPromise = decorator(splitsPromise);
 
     return splitsPromise.then(resp => resp.json());

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

@@ -5,6 +5,7 @@ export type ISplitChangesFetcher = (
   since: number,
   noCache?: boolean,
   till?: number,
+  rbSince?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<ISplitChangesResponse>
 

package/src/sync/polling/pollingManagerCS.ts

@@ -43,10 +43,10 @@ export function pollingManagerCSFactory(
   // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
     if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
-    const splitsHaveSegments = storage.splits.usesSegments();
-    if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
-      log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
-      if (splitsHaveSegments) {
+    const usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+    if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+      log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+      if (usingSegments) {
         startMySegmentsSyncTasks();
       } else {
         stopMySegmentsSyncTasks();
@@ -59,9 +59,9 @@ export function pollingManagerCSFactory(
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady() && !storage.splits.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     }
-    if (!storage.splits.usesSegments()) setTimeout(smartReady, 0);
+    if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) setTimeout(smartReady, 0);
     else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
     mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
@@ -77,7 +77,7 @@ export function pollingManagerCSFactory(
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      if (storage.splits.usesSegments()) startMySegmentsSyncTasks();
+      if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)

package/src/sync/polling/syncTasks/splitsSyncTask.ts

@@ -22,8 +22,7 @@ export function splitsSyncTaskFactory(
     splitChangesUpdaterFactory(
       settings.log,
       splitChangesFetcherFactory(fetchSplitChanges),
-      storage.splits,
-      storage.segments,
+      storage,
       settings.sync.__splitFiltersValidation,
       readiness.splits,
       settings.startup.requestTimeoutBeforeReady,

package/src/sync/polling/types.ts

@@ -1,10 +1,10 @@
-import { ISplit } from '../../dtos/types';
+import { IRBSegment, ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/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, changeNumber: number }], boolean> { }
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit | IRBSegment, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 

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

@@ -27,7 +27,7 @@ export function mySegmentsUpdaterFactory(
   matchingKey: string
 ): IMySegmentsUpdater {
 
-  const { splits, segments, largeSegments } = storage;
+  const { splits, rbSegments, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -51,7 +51,7 @@ export function mySegmentsUpdaterFactory(
     }
 
     // Notify update if required
-    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
       segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }

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

@@ -51,7 +51,7 @@ export function segmentChangesUpdaterFactory(
    * Returned promise will not be rejected.
    *
    * @param fetchOnlyNew - if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
-   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE or RB_SEGMENT_UPDATE notifications.
    * @param segmentName - segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
    * @param noCache - true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
    * @param till - till target for the provided segmentName, for CDN bypass.

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

@@ -1,16 +1,18 @@
-import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
+import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
+import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
-import { IN_SEGMENT } from '../../../utils/constants';
+import { IN_RULE_BASED_SEGMENT, IN_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
+import { SPLIT_UPDATE } from '../../streaming/constants';
 
-type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
+export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
+type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -27,24 +29,24 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
  * Collect segments from a raw split definition.
  * Exported for testing purposes.
  */
-export function parseSegments({ conditions }: ISplit): Set<string> {
-  let segments = new Set<string>();
+export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: typeof IN_SEGMENT | typeof IN_RULE_BASED_SEGMENT = IN_SEGMENT): Set<string> {
+  const { conditions, excluded } = ruleEntity as IRBSegment;
+  const segments = new Set<string>(excluded && excluded.segments);
 
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     matchers.forEach(matcher => {
-      if (matcher.matcherType === IN_SEGMENT) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
     });
   }
 
   return segments;
 }
 
-interface ISplitMutations {
-  added: [string, ISplit][],
-  removed: string[],
-  segments: string[]
+interface ISplitMutations<T extends ISplit | IRBSegment> {
+  added: T[],
+  removed: T[]
 }
 
 /**
@@ -73,25 +75,21 @@ function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
-  const segments = new Set<string>();
-  const computed = entries.reduce((accum, split) => {
-    if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
-      accum.added.push([split.name, split]);
+export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
 
-      parseSegments(split).forEach((segmentName: string) => {
+  return rules.reduce((accum, ruleEntity) => {
+    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
+      accum.added.push(ruleEntity);
+
+      parseSegments(ruleEntity).forEach((segmentName: string) => {
         segments.add(segmentName);
       });
     } else {
-      accum.removed.push(split.name);
+      accum.removed.push(ruleEntity);
     }
 
     return accum;
-  }, { added: [], removed: [], segments: [] } as ISplitMutations);
-
-  computed.segments = setToArray(segments);
-
-  return computed;
+  }, { added: [], removed: [] } as ISplitMutations<T>);
 }
 
 /**
@@ -111,14 +109,14 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
 export function splitChangesUpdaterFactory(
   log: ILogger,
   splitChangesFetcher: ISplitChangesFetcher,
-  splits: ISplitsCacheBase,
-  segments: ISegmentsCacheBase,
+  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
-): ISplitChangesUpdater {
+): SplitChangesUpdater {
+  const { splits, rbSegments, segments } = storage;
 
   let startingUp = true;
 
@@ -128,16 +126,6 @@ export function splitChangesUpdaterFactory(
     return promise;
   }
 
-  /** Returns true if at least one split was updated */
-  function isThereUpdate(flagsChange: [boolean | void, void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
-    const [, added, removed] = flagsChange;
-    // There is at least one added or modified feature flag
-    if (added && added.some((update: boolean) => update)) return true;
-    // There is at least one removed feature flag
-    if (removed && removed.some((update: boolean) => update)) return true;
-    return false;
-  }
-
   /**
    * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
    * Returned promise will not be rejected.
@@ -145,39 +133,53 @@ export function splitChangesUpdaterFactory(
    * @param noCache - true to revalidate data to fetch
    * @param till - query param to bypass CDN requests
    */
-  return function splitChangesUpdater(noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) {
+  return function splitChangesUpdater(noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) {
 
     /**
      * @param since - current changeNumber at splitsCache
      * @param retry - current number of retry attempts
      */
-    function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
-      log.debug(SYNC_SPLITS_FETCH, [since]);
-      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
-        { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
-        splitChangesFetcher(since, noCache, till, _promiseDecorator)
+    function _splitChangesUpdater(sinces: [number, number], retry = 0): Promise<boolean> {
+      const [since, rbSince] = sinces;
+      log.debug(SYNC_SPLITS_FETCH, sinces);
+      const fetcherPromise = Promise.resolve(
+        instantUpdate ?
+          instantUpdate.type === SPLIT_UPDATE ?
+            // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
+            Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
+              return contains ?
+                { ff: { d: [instantUpdate.payload as ISplit], t: instantUpdate.changeNumber } } :
+                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
+            }) :
+            { rbs: { d: [instantUpdate.payload as IRBSegment], t: instantUpdate.changeNumber } } :
+          splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 
-          const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
-
-          log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
-          log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
-          log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
-
-          // Write into storage
-          // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
-          return Promise.all([
-            // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-            splits.setChangeNumber(splitChanges.till),
-            splits.addSplits(mutation.added),
-            splits.removeSplits(mutation.removed),
-            segments.registerSegments(mutation.segments)
-          ]).then((flagsChange) => {
+          const usedSegments = new Set<string>();
+
+          let ffUpdate: MaybeThenable<boolean> = false;
+          if (splitChanges.ff) {
+            const { added, removed } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
+            log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
+            ffUpdate = splits.update(added, removed, splitChanges.ff.t);
+          }
+
+          let rbsUpdate: MaybeThenable<boolean> = false;
+          if (splitChanges.rbs) {
+            const { added, removed } = computeMutation(splitChanges.rbs.d, usedSegments);
+            log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
+            rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
+          }
+
+          return Promise.all([ffUpdate, rbsUpdate,
+            // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
+            segments.registerSegments(setToArray(usedSegments))
+          ]).then(([ffChanged, rbsChanged]) => {
             if (splitsEventEmitter) {
               // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+              return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events
@@ -194,7 +196,7 @@ export function splitChangesUpdaterFactory(
           if (startingUp && retriesOnFailureBeforeReady > retry) {
             retry += 1;
             log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-            return _splitChangesUpdater(since, retry);
+            return _splitChangesUpdater(sinces, retry);
           } else {
             startingUp = false;
           }
@@ -211,7 +213,7 @@ export function splitChangesUpdaterFactory(
       return fetcherPromise;
     }
 
-    let sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
-    return sincePromise.then(_splitChangesUpdater);
+    // `getChangeNumber` never rejects or throws error
+    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
   };
 }

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -84,6 +84,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         case MEMBERSHIPS_MS_UPDATE:
         case MEMBERSHIPS_LS_UPDATE:
         case SPLIT_KILL:
+        case RB_SEGMENT_UPDATE:
           pushEmitter.emit(parsedData.type, parsedData);
           break;
 

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -42,7 +42,7 @@ export interface ISegmentUpdateData {
 }
 
 export interface ISplitUpdateData {
-  type: SPLIT_UPDATE,
+  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
   changeNumber: number,
   pcn?: number,
   d?: string,