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

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

@@ -1,18 +1,16 @@
 import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
+import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } 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_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
-import { IN_RULE_BASED_SEGMENT, IN_SEGMENT } from '../../../utils/constants';
+import { IN_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
 
-export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
-type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
+type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -29,24 +27,24 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
  * Collect segments from a raw split definition.
  * Exported for testing purposes.
  */
-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);
+export function parseSegments({ conditions }: ISplit): Set<string> {
+  let segments = new Set<string>();
 
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     matchers.forEach(matcher => {
-      if (matcher.matcherType === matcherType) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      if (matcher.matcherType === IN_SEGMENT) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
     });
   }
 
   return segments;
 }
 
-interface ISplitMutations<T extends ISplit | IRBSegment> {
-  added: T[],
-  removed: T[]
+interface ISplitMutations {
+  added: ISplit[],
+  removed: ISplit[],
+  segments: string[]
 }
 
 /**
@@ -75,21 +73,25 @@ function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>, segments: Set<string>, filters?: ISplitFiltersValidation): ISplitMutations<T> {
+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);
 
-  return rules.reduce((accum, ruleEntity) => {
-    if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity as ISplit, filters))) {
-      accum.added.push(ruleEntity);
-
-      parseSegments(ruleEntity).forEach((segmentName: string) => {
+      parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);
       });
     } else {
-      accum.removed.push(ruleEntity);
+      accum.removed.push(split);
     }
 
     return accum;
-  }, { added: [], removed: [] } as ISplitMutations<T>);
+  }, { added: [], removed: [], segments: [] } as ISplitMutations);
+
+  computed.segments = setToArray(segments);
+
+  return computed;
 }
 
 /**
@@ -109,14 +111,14 @@ export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>,
 export function splitChangesUpdaterFactory(
   log: ILogger,
   splitChangesFetcher: ISplitChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments'>,
+  storage: Pick<IStorageBase, 'splits' | 'segments'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
-): SplitChangesUpdater {
-  const { splits, rbSegments, segments } = storage;
+): ISplitChangesUpdater {
+  const { splits, segments } = storage;
 
   let startingUp = true;
 
@@ -133,53 +135,34 @@ 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, instantUpdate?: InstantUpdate) {
+  return function splitChangesUpdater(noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) {
 
     /**
      * @param since - current changeNumber at splitsCache
      * @param retry - current number of retry attempts
      */
-    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)
+    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)
       )
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 
-          const usedSegments = new Set<string>();
+          const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
 
-          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);
-          }
+          log.debug(SYNC_SPLITS_UPDATE, [mutation.added.length, mutation.removed.length, mutation.segments.length]);
 
-          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]) => {
+          // Write into storage
+          // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
+          return Promise.all([
+            splits.update(mutation.added, mutation.removed, splitChanges.till),
+            segments.registerSegments(mutation.segments)
+          ]).then(([isThereUpdate]) => {
             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 || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events
@@ -196,7 +179,7 @@ export function splitChangesUpdaterFactory(
           if (startingUp && retriesOnFailureBeforeReady > retry) {
             retry += 1;
             log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-            return _splitChangesUpdater(sinces, retry);
+            return _splitChangesUpdater(since, retry);
           } else {
             startingUp = false;
           }
@@ -213,7 +196,7 @@ export function splitChangesUpdaterFactory(
       return fetcherPromise;
     }
 
-    // `getChangeNumber` never rejects or throws error
-    return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
+    let sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
+    return sincePromise.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, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -84,7 +84,6 @@ 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, RB_SEGMENT_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -42,7 +42,7 @@ export interface ISegmentUpdateData {
 }
 
 export interface ISplitUpdateData {
-  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
+  type: SPLIT_UPDATE,
   changeNumber: number,
   pcn?: number,
   d?: string,

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

@@ -1,16 +1,12 @@
-import { IRBSegment, ISplit } from '../../../dtos/types';
-import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
+import { ISplit } from '../../../dtos/types';
 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 { ISplitsCacheSync } 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';
@@ -18,128 +14,102 @@ 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 } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
-  const ff = SplitsUpdateWorker(storage.splits);
-  const rbs = SplitsUpdateWorker(storage.rbSegments);
+  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);
 
-  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 > 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 __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;
+          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 (maxChangeNumber <= splitsCache.getChangeNumber()) {
+            log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
+            isHandlingEvent = false;
+            return;
+          }
 
-            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-              backoff.scheduleCall();
-              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();
-            }
+          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;
     }
+  }
 
-    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();
+  /**
+   * 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();
 
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+    if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-        instantUpdate = undefined;
+    maxChangeNumber = changeNumber;
+    handleNewEvent = true;
+    cdnBypass = false;
+    payload = undefined;
 
-        if (payload && currentChangeNumber === pcn) {
-          instantUpdate = { payload, changeNumber, type };
-        }
+    if (_payload && currentChangeNumber === pcn) {
+      payload = _payload;
+    }
 
-        if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
-        backoff.reset();
-      },
-      stop() {
-        isHandlingEvent = false;
-        backoff.reset();
-      },
-      isSync() {
-        return maxChangeNumber <= cache.getChangeNumber();
-      }
-    };
+    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+    backoff.reset();
   }
 
   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);
-    },
+    put,
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
-     * @param changeNumber - change number of the notification
+     * @param changeNumber - change number of the SPLIT_UPDATE 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)) {
+      if (splitsCache.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);
+      put({ changeNumber } as ISplitUpdateData);
     },
 
     stop() {
-      ff.stop();
-      rbs.stop();
+      isHandlingEvent = false;
+      backoff.reset();
     }
   };
 }

package/src/sync/streaming/constants.ts

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

package/src/sync/streaming/parseUtils.ts

@@ -2,7 +2,7 @@ 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';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -82,7 +82,7 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 /**
  * Parse feature flags notifications for instant feature flag updates
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | IRBSegment | undefined {
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
   return compression > 0 ?
     parseKeyList(data, compression, false) :
     JSON.parse(decodeFromBase64(data));

package/src/sync/streaming/pushManager.ts

@@ -11,10 +11,10 @@ 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 { 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, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -56,7 +56,7 @@ export function pushManagerFactory(
   // 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);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, 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> = {};
@@ -219,8 +219,20 @@ export function pushManagerFactory(
   /** 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);
+  pushEmitter.on(SPLIT_UPDATE, (parsedData) => {
+    if (parsedData.d && parsedData.c !== undefined) {
+      try {
+        const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+        if (payload) {
+          splitsUpdateWorker.put(parsedData, payload);
+          return;
+        }
+      } catch (e) {
+        log.warn(STREAMING_PARSING_SPLIT_UPDATE, [e]);
+      }
+    }
+    splitsUpdateWorker.put(parsedData);
+  });
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {

package/src/sync/streaming/types.ts

@@ -16,19 +16,18 @@ 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';
-export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-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 | RB_SEGMENT_UPDATE | 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 MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
   T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
-  T extends SPLIT_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**

package/src/sync/submitters/impressionsSubmitter.ts

@@ -25,8 +25,9 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           m: entry.time, // Timestamp
           c: entry.changeNumber, // ChangeNumber
           r: sendLabels ? entry.label : undefined, // Rule
-          b: entry.bucketingKey ? entry.bucketingKey : undefined, // Bucketing Key
-          pt: entry.pt ? entry.pt : undefined // Previous time
+          b: entry.bucketingKey, // Bucketing Key
+          pt: entry.pt, // Previous time
+          properties: entry.properties // Properties
         };
 
         return keyImpression;

package/src/sync/submitters/types.ts

@@ -3,26 +3,30 @@ import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
+type ImpressionPayload = {
+  /** Matching Key */
+  k: string;
+  /** Bucketing Key */
+  b?: string;
+  /** Treatment */
+  t: string;
+  /** Timestamp */
+  m: number;
+  /** Change number */
+  c: number;
+  /** Rule label */
+  r?: string;
+  /** Previous time */
+  pt?: number;
+  /** Stringified JSON object with properties */
+  properties?: string;
+};
+
 export type ImpressionsPayload = {
   /** Split name */
   f: string,
   /** Key Impressions */
-  i: {
-    /** User Key */
-    k: string;
-    /** Treatment */
-    t: string;
-    /** Timestamp */
-    m: number;
-    /** ChangeNumber */
-    c: number;
-    /** Rule label */
-    r?: string;
-    /** Bucketing Key */
-    b?: string;
-    /** Previous time */
-    pt?: number;
-  }[]
+  i: ImpressionPayload[]
 }[]
 
 export type ImpressionCountsPayload = {
@@ -60,23 +64,9 @@ export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored impression */
-  i: {
-    /** keyName */
-    k: string,
-    /** bucketingKey */
-    b?: string,
-    /** Split name */
-    f: string,
-    /** treatment */
-    t: string,
-    /** label */
-    r: string,
-    /** changeNumber */
-    c: number,
-    /** time */
-    m: number
-    /** previous time */
-    pt?: number
+  i: ImpressionPayload & {
+    /** Feature flag name */
+    f: string
   }
 }
 

package/src/sync/syncManagerOnline.ts

@@ -149,14 +149,14 @@ export function syncManagerOnlineFactory(
             if (pushManager) {
               if (pollingManager.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
-                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               } else {
                 // if not polling, we must execute the sync task for the initial fetch
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
             } else {
-              if (storage.splits.usesSegments() || storage.rbSegments.usesSegments()) mySegmentsSyncTask.start();
+              if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
           } else {
             if (!readinessManager.isReady()) mySegmentsSyncTask.execute();