@splitsoftware/splitio-commons 2.3.0 → 2.3.1-rc.0

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

@@ -1,24 +1,85 @@
+import { ISettings } from '../../../types';
+import { ISplitChangesResponse } from '../../../dtos/types';
 import { IFetchSplitChanges, IResponse } from '../../../services/types';
+import { IStorageBase } from '../../../storages/types';
+import { FLAG_SPEC_VERSION } from '../../../utils/constants';
+import { base } from '../../../utils/settingsValidation';
 import { ISplitChangesFetcher } from './types';
+import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+
+const PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
+const PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
+
+function sdkEndpointOverridden(settings: ISettings) {
+  return settings.urls.sdk !== base.urls.sdk;
+}
 
 /**
  * Factory of SplitChanges fetcher.
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
-export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher {
+// @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
+export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
+
+  const log = settings.log;
+  const PROXY_CHECK_INTERVAL_MILLIS = settings.core.key !== undefined ? PROXY_CHECK_INTERVAL_MILLIS_CS : PROXY_CHECK_INTERVAL_MILLIS_SS;
+  let lastProxyCheckTimestamp: number | undefined;
 
   return function splitChangesFetcher(
     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>
-  ) {
+  ): Promise<ISplitChangesResponse> {
+
+    // Recheck proxy
+    if (lastProxyCheckTimestamp && (Date.now() - lastProxyCheckTimestamp) > PROXY_CHECK_INTERVAL_MILLIS) {
+      settings.sync.flagSpecVersion = FLAG_SPEC_VERSION;
+    }
+
+    let splitsPromise = fetchSplitChanges(since, noCache, till, settings.sync.flagSpecVersion === FLAG_SPEC_VERSION ? rbSince : undefined)
+      // Handle proxy error with spec 1.3
+      .catch((err) => {
+        if (err.statusCode === 400 && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === FLAG_SPEC_VERSION) {
+          log.error(LOG_PREFIX_SYNC_SPLITS + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
+          lastProxyCheckTimestamp = Date.now();
+          settings.sync.flagSpecVersion = '1.2'; // fallback to 1.2 spec
+          return fetchSplitChanges(since, noCache, till); // retry request without rbSince
+        }
+        throw err;
+      });
 
-    let splitsPromise = fetchSplitChanges(since, noCache, till);
     if (decorator) splitsPromise = decorator(splitsPromise);
 
-    return splitsPromise.then(resp => resp.json());
+    return splitsPromise
+      .then(resp => resp.json())
+      .then(data => {
+        // Using flag spec version 1.2 or below
+        if (data.splits) {
+          return {
+            ff: {
+              d: data.splits,
+              s: data.since,
+              t: data.till
+            }
+          };
+        }
+
+        // Proxy recovery
+        if (lastProxyCheckTimestamp) {
+          log.info(LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
+          lastProxyCheckTimestamp = undefined;
+          return splitChangesFetcher(-1, undefined, undefined, -1)
+            .then((splitChangesResponse: ISplitChangesResponse) =>
+              Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+                .then(() => splitChangesResponse)
+            );
+        }
+
+        return data;
+      });
   };
 
 }

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

@@ -21,7 +21,7 @@ export function splitsSyncTaskFactory(
     settings.log,
     splitChangesUpdaterFactory(
       settings.log,
-      splitChangesFetcherFactory(fetchSplitChanges),
+      splitChangesFetcherFactory(fetchSplitChanges, settings, storage),
       storage,
       settings.sync.__splitFiltersValidation,
       readiness.splits,

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, 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 } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, 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, RULE_BASED_SEGMENT, STANDARD_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.
@@ -24,27 +26,35 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
 }
 
 /**
- * Collect segments from a raw split definition.
+ * Collect segments from a raw FF or RBS 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>();
+  if (excluded && excluded.segments) {
+    excluded.segments.forEach(({ type, name }) => {
+      if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
+        segments.add(name);
+      }
+    });
+  }
 
   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: ISplit[],
-  removed: ISplit[],
-  segments: string[]
+interface ISplitMutations<T extends ISplit | IRBSegment> {
+  added: T[],
+  removed: T[]
 }
 
 /**
@@ -73,25 +83,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);
+export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
+
+  return rules.reduce((accum, ruleEntity) => {
+    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
+      accum.added.push(ruleEntity);
 
-      parseSegments(split).forEach((segmentName: string) => {
+      parseSegments(ruleEntity).forEach((segmentName: string) => {
         segments.add(segmentName);
       });
     } else {
-      accum.removed.push(split);
+      accum.removed.push(ruleEntity);
     }
 
     return accum;
-  }, { added: [], removed: [], segments: [] } as ISplitMutations);
-
-  computed.segments = setToArray(segments);
-
-  return computed;
+  }, { added: [], removed: [] } as ISplitMutations<T>);
 }
 
 /**
@@ -111,14 +117,14 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
 export function splitChangesUpdaterFactory(
   log: ILogger,
   splitChangesFetcher: ISplitChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'segments'>,
+  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
-): ISplitChangesUpdater {
-  const { splits, segments } = storage;
+): SplitChangesUpdater {
+  const { splits, rbSegments, segments } = storage;
 
   let startingUp = true;
 
@@ -135,32 +141,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]);
-      return 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);
+      return 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);
+          const usedSegments = new Set<string>();
 
-          log.debug(SYNC_SPLITS_UPDATE, [mutation.added.length, mutation.removed.length, mutation.segments.length]);
+          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([
-            splits.update(mutation.added, mutation.removed, splitChanges.till),
-            segments.registerSegments(mutation.segments)
-          ]).then(([isThereUpdate]) => {
+          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 && (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
@@ -177,7 +204,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;
           }
@@ -185,7 +212,7 @@ export function splitChangesUpdaterFactory(
         });
     }
 
-    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,

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

@@ -1,12 +1,16 @@
-import { ISplit } from '../../../dtos/types';
+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 { ISplitsCacheSync } from '../../../storages/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';
@@ -14,102 +18,128 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, storage: IStorageSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killSplit(event: ISplitKillData): void } {
 
-  let maxChangeNumber = 0;
-  let handleNewEvent = false;
-  let isHandlingEvent: boolean;
-  let cdnBypass: boolean;
-  let payload: ISplit | undefined;
-  const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+  const ff = SplitsUpdateWorker(storage.splits);
+  const rbs = SplitsUpdateWorker(storage.rbSegments);
 
-  function __handleSplitUpdateCall() {
-    isHandlingEvent = true;
-    if (maxChangeNumber > splitsCache.getChangeNumber()) {
-      handleNewEvent = false;
-      const splitUpdateNotification = payload ? { payload, changeNumber: maxChangeNumber } : undefined;
-      // fetch splits revalidating data if cached
-      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification).then(() => {
-        if (!isHandlingEvent) return; // halt if `stop` has been called
-        if (handleNewEvent) {
-          __handleSplitUpdateCall();
-        } else {
-          if (splitUpdateNotification) telemetryTracker.trackUpdatesFromSSE(SPLITS);
-          // fetch new registered segments for server-side API. Not retrying on error
-          if (segmentsSyncTask) segmentsSyncTask.execute(true);
+  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);
 
-          const attempts = backoff.attempts + 1;
+    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);
 
-          if (maxChangeNumber <= splitsCache.getChangeNumber()) {
-            log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
-            isHandlingEvent = false;
-            return;
-          }
+            const attempts = backoff.attempts + 1;
 
-          if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-            backoff.scheduleCall();
-            return;
-          }
+            if (ff.isSync() && rbs.isSync()) {
+              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+              isHandlingEvent = false;
+              return;
+            }
 
-          if (cdnBypass) {
-            log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
-            isHandlingEvent = false;
-          } else {
-            backoff.reset();
-            cdnBypass = true;
-            __handleSplitUpdateCall();
+            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;
+        });
+      } else {
+        isHandlingEvent = false;
+      }
     }
-  }
 
-  /**
-   * Invoked by NotificationProcessor on SPLIT_UPDATE event
-   *
-   * @param changeNumber - change number of the SPLIT_UPDATE notification
-   */
-  function put({ changeNumber, pcn }: ISplitUpdateData, _payload?: ISplit) {
-    const currentChangeNumber = splitsCache.getChangeNumber();
+    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;
+        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-    maxChangeNumber = changeNumber;
-    handleNewEvent = true;
-    cdnBypass = false;
-    payload = undefined;
+        maxChangeNumber = changeNumber;
+        handleNewEvent = true;
+        cdnBypass = false;
+        instantUpdate = undefined;
 
-    if (_payload && currentChangeNumber === pcn) {
-      payload = _payload;
-    }
+        if (payload && currentChangeNumber === pcn) {
+          instantUpdate = { payload, changeNumber, type };
+        }
 
-    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
-    backoff.reset();
+        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+        backoff.reset();
+      },
+      stop() {
+        isHandlingEvent = false;
+        backoff.reset();
+      },
+      isSync() {
+        return maxChangeNumber <= cache.getChangeNumber();
+      }
+    };
   }
 
   return {
-    put,
+    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 SPLIT_UPDATE notification
+     * @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 (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+      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)
-      put({ changeNumber } as ISplitUpdateData);
+      ff.put({ changeNumber } as ISplitUpdateData);
     },
 
     stop() {
-      isHandlingEvent = false;
-      backoff.reset();
+      ff.stop();
+      rbs.stop();
     }
   };
 }

package/src/sync/streaming/constants.ts

@@ -30,6 +30,7 @@ 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';