@splitsoftware/splitio-commons 2.2.1-rc.5 → 2.3.0

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -47,14 +47,16 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private _incrementCounts(split: ISplit) {
     try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      // @ts-expect-error
-      localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+      if (split) {
+        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         // @ts-expect-error
-        localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+        localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+
+        if (usesSegments(split)) {
+          const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+          // @ts-expect-error
+          localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+        }
       }
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -183,9 +185,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
+    if (isFiniteNumber(splitsWithSegmentsCount)) {
+      return splitsWithSegmentsCount > 0;
+    } else {
+      return true;
+    }
   }
 
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {

package/src/storages/inLocalStorage/index.ts

@@ -6,7 +6,6 @@ import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
@@ -37,13 +36,11 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const keys = new KeyBuilderCS(prefix, matchingKey);
 
     const splits = new SplitsCacheInLocal(settings, keys);
-    const rbSegments = new RBSegmentsCacheInLocal(settings, keys);
     const segments = new MySegmentsCacheInLocal(log, keys);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
     return {
       splits,
-      rbSegments,
       segments,
       largeSegments,
       impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
@@ -53,7 +50,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
       validateCache() {
-        return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
+        return validateCache(options, settings, keys, splits, segments, largeSegments);
       },
 
       destroy() { },
@@ -63,7 +60,6 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
 
         return {
           splits: this.splits,
-          rbSegments: this.rbSegments,
           segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
           largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
           impressions: this.impressions,

package/src/storages/inLocalStorage/validateCache.ts

@@ -3,7 +3,6 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { getStorageHash } from '../KeyBuilder';
 import { LOG_PREFIX } from './constants';
 import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import SplitIO from '../../../types/splitio';
@@ -67,14 +66,13 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: IS
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
+export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
 
   const currentTimestamp = Date.now();
   const isThereCache = splits.getChangeNumber() > -1;
 
   if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
     splits.clear();
-    rbSegments.clear();
     segments.clear();
     largeSegments.clear();
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -7,7 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -18,12 +17,10 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
-  const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new SegmentsCacheInMemory();
 
   const storage = {
     splits,
-    rbSegments,
     segments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: new ImpressionCountsCacheInMemory(),

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,7 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -18,13 +17,11 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
-  const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new MySegmentsCacheInMemory();
   const largeSegments = new MySegmentsCacheInMemory();
 
   const storage = {
     splits,
-    rbSegments,
     segments,
     largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
@@ -39,7 +36,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     shared() {
       return {
         splits: this.splits,
-        rbSegments: this.rbSegments,
         segments: new MySegmentsCacheInMemory(),
         largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -24,7 +24,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.ttCache = {};
     this.changeNumber = -1;
     this.segmentsCount = 0;
-    this.flagSetsCache = {};
   }
 
   addSplit(split: ISplit): boolean {

package/src/storages/inRedis/index.ts

@@ -11,7 +11,6 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 import { metadataBuilder } from '../utils';
-import { RBSegmentsCacheInRedis } from './RBSegmentsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -60,7 +59,6 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
     return {
       splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
-      rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/pluggable/index.ts

@@ -20,7 +20,6 @@ import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { metadataBuilder } from '../utils';
 import { LOG_PREFIX } from '../pluggable/constants';
-import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
@@ -118,7 +117,6 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
-      rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/types.ts

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse } from '../dtos/types';
+import { MaybeThenable, ISplit, 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';
@@ -221,34 +221,6 @@ 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 {
@@ -447,7 +419,6 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
 
 export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
-  TRBSegmentsCache extends IRBSegmentsCacheBase = IRBSegmentsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
   TImpressionsCountCache extends IImpressionCountsCacheBase = IImpressionCountsCacheBase,
@@ -456,7 +427,6 @@ export interface IStorageBase<
   TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
   splits: TSplitsCache,
-  rbSegments: TRBSegmentsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
   impressionCounts: TImpressionsCountCache,
@@ -469,7 +439,6 @@ export interface IStorageBase<
 
 export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
-  IRBSegmentsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
   IImpressionCountsCacheSync,
@@ -484,7 +453,6 @@ export interface IStorageSync extends IStorageBase<
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
-  IRBSegmentsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
   IImpressionCountsCacheBase,

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

@@ -1,85 +1,24 @@
-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.
  */
-// @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;
+export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher {
 
   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())
-      .then(data => {
-        // Using flag spec version 1.2
-        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;
-      });
+    return splitsPromise.then(resp => resp.json());
   };
 
 }

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

@@ -5,7 +5,6 @@ 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 usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-    if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-      log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-      if (usingSegments) {
+    const splitsHaveSegments = storage.splits.usesSegments();
+    if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+      log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+      if (splitsHaveSegments) {
         startMySegmentsSyncTasks();
       } else {
         stopMySegmentsSyncTasks();
@@ -59,9 +59,9 @@ export function pollingManagerCSFactory(
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      if (!readiness.isReady() && !storage.splits.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     }
-    if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments()) setTimeout(smartReady, 0);
+    if (!storage.splits.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() || storage.rbSegments.usesSegments()) startMySegmentsSyncTasks();
+      if (storage.splits.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, settings, storage),
+      splitChangesFetcherFactory(fetchSplitChanges),
       storage,
       settings.sync.__splitFiltersValidation,
       readiness.splits,

package/src/sync/polling/types.ts

@@ -1,10 +1,10 @@
-import { IRBSegment, ISplit } from '../../dtos/types';
+import { 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 | IRBSegment, changeNumber: number }], boolean> { }
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, 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, rbSegments, segments, largeSegments } = storage;
+  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -51,7 +51,7 @@ export function mySegmentsUpdaterFactory(
     }
 
     // Notify update if required
-    if ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (splits.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 or RB_SEGMENT_UPDATE notifications.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_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.