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

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,5 @@
 import { ISplitsCacheSync } from './types';
-import { ISplit } from '../dtos/types';
+import { IRBSegment, ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
@@ -9,16 +9,14 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: ISplit): boolean
+  protected abstract addSplit(split: ISplit): boolean
+  protected abstract removeSplit(name: string): boolean
+  protected abstract setChangeNumber(changeNumber: number): boolean | void
 
-  addSplits(entries: [string, ISplit][]): boolean[] {
-    return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
-  }
-
-  abstract removeSplit(name: string): boolean
-
-  removeSplits(names: string[]): boolean[] {
-    return names.map(name => this.removeSplit(name));
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null
@@ -31,8 +29,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean | void
-
   abstract getChangeNumber(): number
 
   getAll(): ISplit[] {
@@ -47,6 +43,14 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract clear(): void
 
+  /**
+   * Check if the splits information is already stored in cache. This data can be preloaded.
+   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+   */
+  checkCache(): boolean {
+    return false;
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.
@@ -63,7 +67,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
       newSplit.defaultTreatment = defaultTreatment;
       newSplit.changeNumber = changeNumber;
 
-      return this.addSplit(name, newSplit);
+      return this.addSplit(newSplit);
     }
     return false;
   }
@@ -76,8 +80,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
  * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesSegments(split: ISplit) {
-  const conditions = split.conditions || [];
+export function usesSegments(ruleEntity: ISplit | IRBSegment) {
+  const conditions = ruleEntity.conditions || [];
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
 
@@ -87,5 +91,8 @@ export function usesSegments(split: ISplit) {
     }
   }
 
+  const excluded = (ruleEntity as IRBSegment).excluded;
+  if (excluded && excluded.segments && excluded.segments.length > 0) return true;
+
   return false;
 }

package/src/storages/KeyBuilder.ts

@@ -1,5 +1,4 @@
 import { ISettings } from '../types';
-import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 
 const everythingAtTheEnd = /[^.]+$/;
@@ -34,22 +33,20 @@ export class KeyBuilder {
     return `${this.prefix}.splits.till`;
   }
 
-  // NOT USED
-  // buildSplitsReady() {
-  //   return `${this.prefix}.splits.ready`;
-  // }
+  buildSplitKeyPrefix() {
+    return `${this.prefix}.split.`;
+  }
 
-  isSplitKey(key: string) {
-    return startsWith(key, `${this.prefix}.split.`);
+  buildRBSegmentKey(rbsegmentName: string) {
+    return `${this.prefix}.rbsegment.${rbsegmentName}`;
   }
 
-  buildSplitKeyPrefix() {
-    return `${this.prefix}.split.`;
+  buildRBSegmentsTillKey() {
+    return `${this.prefix}.rbsegments.till`;
   }
 
-  // Only used by InLocalStorage.
-  buildSplitsWithSegmentCountKey() {
-    return `${this.prefix}.splits.usingSegments`;
+  buildRBSegmentKeyPrefix() {
+    return `${this.prefix}.rbsegment.`;
   }
 
   buildSegmentNameKey(segmentName: string) {
@@ -60,11 +57,6 @@ export class KeyBuilder {
     return `${this.prefix}.segment.${segmentName}.till`;
   }
 
-  // NOT USED
-  // buildSegmentsReady() {
-  //   return `${this.prefix}.segments.ready`;
-  // }
-
   extractKey(builtKey: string) {
     const s = builtKey.match(everythingAtTheEnd);
 

package/src/storages/KeyBuilderCS.ts

@@ -15,7 +15,7 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   constructor(prefix: string, matchingKey: string) {
     super(prefix);
     this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
+    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet|rbsegment)\\.`);
   }
 
   /**
@@ -28,8 +28,7 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   extractSegmentName(builtSegmentKeyName: string) {
     const prefix = `${this.prefix}.${this.matchingKey}.segment.`;
 
-    if (startsWith(builtSegmentKeyName, prefix))
-      return builtSegmentKeyName.substr(prefix.length);
+    if (startsWith(builtSegmentKeyName, prefix)) return builtSegmentKeyName.slice(prefix.length);
   }
 
   buildLastUpdatedKey() {
@@ -44,8 +43,16 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     return `${this.prefix}.${this.matchingKey}.segments.till`;
   }
 
-  buildLastClear() {
-    return `${this.prefix}.lastClear`;
+  isSplitKey(key: string) {
+    return startsWith(key, `${this.prefix}.split.`);
+  }
+
+  isRBSegmentKey(key: string) {
+    return startsWith(key, `${this.prefix}.rbsegment.`);
+  }
+
+  buildSplitsWithSegmentCountKey() {
+    return `${this.prefix}.splits.usingSegments`;
   }
 }
 
@@ -58,7 +65,7 @@ export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string):
     extractSegmentName(builtSegmentKeyName: string) {
       const p = `${prefix}.${matchingKey}.largeSegment.`;
 
-      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
+      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.slice(p.length);
     },
 
     buildTillKey() {

package/src/storages/KeyBuilderSS.ts

@@ -53,6 +53,10 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.buildSplitKeyPrefix()}*`;
   }
 
+  searchPatternForRBSegmentKeys() {
+    return `${this.buildRBSegmentKeyPrefix()}*`;
+  }
+
   /* Telemetry keys */
 
   buildLatencyKey(method: Method, bucket: number) {

package/src/storages/dataLoader.ts

@@ -1,9 +1,7 @@
 import { PreloadedData } from '../types';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
-// This value might be eventually set via a config parameter
-const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-
 /**
  * Factory of client-side storage loader
  *
@@ -37,10 +35,9 @@ export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
-    storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+    storage.splits.update(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])), [], since);
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -0,0 +1,136 @@
+import { IRBSegment } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
+import { ISettings } from '../../types';
+import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import { IRBSegmentsCacheSync } from '../types';
+import { LOG_PREFIX } from './constants';
+
+export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
+
+  private readonly keys: KeyBuilderCS;
+  private readonly log: ILogger;
+
+  constructor(settings: ISettings, keys: KeyBuilderCS) {
+    this.keys = keys;
+    this.log = settings.log;
+  }
+
+  clear() {
+    this.getNames().forEach(name => this.remove(name));
+    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
+    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+  }
+
+  private setChangeNumber(changeNumber: number) {
+    try {
+      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+    }
+  }
+
+  private updateSegmentCount(diff: number) {
+    const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
+    // @ts-expect-error
+    if (count > 0) localStorage.setItem(segmentsCountKey, count);
+    else localStorage.removeItem(segmentsCountKey);
+  }
+
+  private add(rbSegment: IRBSegment): boolean {
+    try {
+      const name = rbSegment.name;
+      const rbSegmentKey = this.keys.buildRBSegmentKey(name);
+      const rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+      const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+
+      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+
+      let usesSegmentsDiff = 0;
+      if (previous && usesSegments(previous)) usesSegmentsDiff--;
+      if (usesSegments(rbSegment)) usesSegmentsDiff++;
+      if (usesSegmentsDiff !== 0) this.updateSegmentCount(usesSegmentsDiff);
+
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
+  }
+
+  private remove(name: string): boolean {
+    try {
+      const rbSegment = this.get(name);
+      if (!rbSegment) return false;
+
+      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+
+      if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
+
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
+  }
+
+  private getNames(): string[] {
+    const len = localStorage.length;
+    const accum = [];
+
+    let cur = 0;
+
+    while (cur < len) {
+      const key = localStorage.key(cur);
+
+      if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
+
+      cur++;
+    }
+
+    return accum;
+  }
+
+  get(name: string): IRBSegment | null {
+    const item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    return item && JSON.parse(item);
+  }
+
+  contains(names: Set<string>): boolean {
+    const namesArray = setToArray(names);
+    const namesInStorage = this.getNames();
+    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
+  }
+
+  getChangeNumber(): number {
+    const n = -1;
+    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+
+    if (value !== null) {
+      value = parseInt(value, 10);
+
+      return isNaNNumber(value) ? n : value;
+    }
+
+    return n;
+  }
+
+  usesSegments(): boolean {
+    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+
+    return isFiniteNumber(splitsWithSegmentsCount) ?
+      splitsWithSegmentsCount > 0 :
+      true;
+  }
+
+}

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -5,6 +5,7 @@ import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
+import { getStorageHash } from '../KeyBuilder';
 import { setToArray } from '../../utils/lang/sets';
 
 /**
@@ -14,14 +15,21 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
+  private readonly storageHash: string;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
+  private updateNewFilter?: boolean;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number) {
     super();
     this.keys = keys;
     this.log = settings.log;
+    this.storageHash = getStorageHash(settings);
     this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+
+    this._checkExpiration(expirationTimestamp);
+
+    this._checkFilterQuery();
   }
 
   private _decrementCount(key: string) {
@@ -49,16 +57,14 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private _incrementCounts(split: ISplit) {
     try {
-      if (split) {
-        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        // @ts-expect-error
-        localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+      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();
-          // @ts-expect-error
-          localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 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);
@@ -71,6 +77,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
    */
   clear() {
+    this.log.info(LOG_PREFIX + 'Flushing Splits data from localStorage');
+
     // collect item keys
     const len = localStorage.length;
     const accum = [];
@@ -86,8 +94,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(name: string, split: ISplit) {
+  addSplit(split: ISplit) {
     try {
+      const name = split.name;
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
@@ -110,6 +119,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   removeSplit(name: string): boolean {
     try {
       const split = this.getSplit(name);
+      if (!split) return false;
+
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
       this._decrementCounts(split);
@@ -122,12 +133,25 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
-  getSplit(name: string) {
+  getSplit(name: string): ISplit | null {
     const item = localStorage.getItem(this.keys.buildSplitKey(name));
     return item && JSON.parse(item);
   }
 
   setChangeNumber(changeNumber: number): boolean {
+
+    // when using a new split query, we must update it at the store
+    if (this.updateNewFilter) {
+      this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
+      const storageHashKey = this.keys.buildHashKey();
+      try {
+        localStorage.setItem(storageHashKey, this.storageHash);
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
+      this.updateNewFilter = false;
+    }
+
     try {
       localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
@@ -182,11 +206,51 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
-    if (isFiniteNumber(splitsWithSegmentsCount)) {
-      return splitsWithSegmentsCount > 0;
-    } else {
-      return true;
+    return isFiniteNumber(splitsWithSegmentsCount) ?
+      splitsWithSegmentsCount > 0 :
+      true;
+  }
+
+  /**
+   * Check if the splits information is already stored in browser LocalStorage.
+   * In this function we could add more code to check if the data is valid.
+   * @override
+   */
+  checkCache(): boolean {
+    return this.getChangeNumber() > -1;
+  }
+
+  /**
+   * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+   *
+   * @param expirationTimestamp - if the value is not a number, data will not be cleaned
+   */
+  private _checkExpiration(expirationTimestamp?: number) {
+    let value: string | number | null = localStorage.getItem(this.keys.buildLastUpdatedKey());
+    if (value !== null) {
+      value = parseInt(value, 10);
+      if (!isNaNNumber(value) && expirationTimestamp && value < expirationTimestamp) this.clear();
+    }
+  }
+
+  // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
+  private _checkFilterQuery() {
+    const storageHashKey = this.keys.buildHashKey();
+    const storageHash = localStorage.getItem(storageHashKey);
+
+    if (storageHash !== this.storageHash) {
+      try {
+        // mark cache to update the new query filter on first successful splits fetch
+        this.updateNewFilter = true;
+
+        // if there is cache, clear it
+        if (this.checkCache()) this.clear();
+
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
     }
+    // if the filter didn't change, nothing is done
   }
 
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {

package/src/storages/inLocalStorage/index.ts

@@ -7,19 +7,23 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
 import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
-import SplitIO from '../../../types/splitio';
+import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
+
+export interface InLocalStorageOptions {
+  prefix?: string
+}
 
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): IStorageSyncFactory {
+export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
@@ -34,13 +38,16 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
+    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    const splits = new SplitsCacheInLocal(settings, keys);
+    const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
+    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),
@@ -49,10 +56,6 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
-      validateCache() {
-        return validateCache(options, settings, keys, splits, segments, largeSegments);
-      },
-
       destroy() { },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
@@ -60,6 +63,7 @@ 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/inMemory/InMemoryStorage.ts

@@ -7,6 +7,7 @@ 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
@@ -17,10 +18,12 @@ 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,6 +7,7 @@ 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
@@ -17,11 +18,13 @@ 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),
@@ -36,6 +39,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     shared() {
       return {
         splits: this.splits,
+        rbSegments: this.rbSegments,
         segments: new MySegmentsCacheInMemory(),
         largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,