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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -57,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);
@@ -96,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;
@@ -120,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);
@@ -132,7 +133,7 @@ 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);
   }
@@ -205,11 +206,9 @@ 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;
   }
 
   /**

package/src/storages/inLocalStorage/index.ts

@@ -14,6 +14,7 @@ import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
+import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -40,11 +41,13 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
     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),
@@ -60,6 +63,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
         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,

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -0,0 +1,68 @@
+import { IRBSegment } from '../../dtos/types';
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+import { IRBSegmentsCacheSync } from '../types';
+
+export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
+
+  private cache: Record<string, IRBSegment> = {};
+  private changeNumber: number = -1;
+  private segmentsCount: number = 0;
+
+  clear() {
+    this.cache = {};
+    this.changeNumber = -1;
+    this.segmentsCount = 0;
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    this.changeNumber = 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 add(rbSegment: IRBSegment): boolean {
+    const name = rbSegment.name;
+    const previous = this.get(name);
+    if (previous && usesSegments(previous)) this.segmentsCount--;
+
+    this.cache[name] = rbSegment;
+    if (usesSegments(rbSegment)) this.segmentsCount++;
+
+    return true;
+  }
+
+  private remove(name: string): boolean {
+    const rbSegment = this.get(name);
+    if (!rbSegment) return false;
+
+    delete this.cache[name];
+
+    if (usesSegments(rbSegment)) this.segmentsCount--;
+
+    return true;
+  }
+
+  private getNames(): string[] {
+    return Object.keys(this.cache);
+  }
+
+  get(name: string): IRBSegment | null {
+    return this.cache[name] || null;
+  }
+
+  contains(names: Set<string>): boolean {
+    const namesArray = setToArray(names);
+    const namesInStorage = this.getNames();
+    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
+  }
+
+  getChangeNumber(): number {
+    return this.changeNumber;
+  }
+
+  usesSegments(): boolean {
+    return this.segmentsCount > 0;
+  }
+
+}

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -26,7 +26,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.segmentsCount = 0;
   }
 
-  addSplit(name: string, split: ISplit): boolean {
+  addSplit(split: ISplit): boolean {
+    const name = split.name;
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
 
@@ -40,41 +41,35 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       if (usesSegments(previousSplit)) this.segmentsCount--;
     }
 
-    if (split) {
-      // Store the Split.
-      this.splitsCache[name] = split;
-      // Update TT cache
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-      this.addToFlagSets(split);
+    // Store the Split.
+    this.splitsCache[name] = split;
+    // Update TT cache
+    const ttName = split.trafficTypeName;
+    this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+    this.addToFlagSets(split);
 
-      // Add to segments count for the new version of the Split
-      if (usesSegments(split)) this.segmentsCount++;
+    // Add to segments count for the new version of the Split
+    if (usesSegments(split)) this.segmentsCount++;
 
-      return true;
-    } else {
-      return false;
-    }
+    return true;
   }
 
   removeSplit(name: string): boolean {
     const split = this.getSplit(name);
-    if (split) {
-      // Delete the Split
-      delete this.splitsCache[name];
+    if (!split) return false;
 
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName]--; // Update tt cache
-      if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      this.removeFromFlagSets(split.name, split.sets);
+    // Delete the Split
+    delete this.splitsCache[name];
 
-      // Update the segments count.
-      if (usesSegments(split)) this.segmentsCount--;
+    const ttName = split.trafficTypeName;
+    this.ttCache[ttName]--; // Update tt cache
+    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+    this.removeFromFlagSets(split.name, split.sets);
 
-      return true;
-    } else {
-      return false;
-    }
+    // Update the segments count.
+    if (usesSegments(split)) this.segmentsCount--;
+
+    return true;
   }
 
   getSplit(name: string): ISplit | null {

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -0,0 +1,79 @@
+import { isNaNNumber } from '../../utils/lang';
+import { IRBSegmentsCacheAsync } from '../types';
+import { ILogger } from '../../logger/types';
+import { IRBSegment } from '../../dtos/types';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+import { RedisAdapter } from './RedisAdapter';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+
+export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilderSS;
+  private readonly redis: RedisAdapter;
+
+  constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter) {
+    this.log = log;
+    this.keys = keys;
+    this.redis = redis;
+  }
+
+  get(name: string): Promise<IRBSegment | null> {
+    return this.redis.get(this.keys.buildRBSegmentKey(name))
+      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
+  }
+
+  private getNames(): Promise<string[]> {
+    return this.redis.keys(this.keys.searchPatternForRBSegmentKeys()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  contains(names: Set<string>): Promise<boolean> {
+    const namesArray = setToArray(names);
+    return this.getNames().then(namesInStorage => {
+      return namesArray.every(name => namesInStorage.includes(name));
+    });
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(toAdd => {
+        const key = this.keys.buildRBSegmentKey(toAdd.name);
+        const stringifiedNewRBSegment = JSON.stringify(toAdd);
+        return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
+      })),
+      Promise.all(toRemove.map(toRemove => {
+        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        return this.redis.del(key).then(status => status === 1);
+      }))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
+  setChangeNumber(changeNumber: number) {
+    return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
+      status => status === 'OK'
+    );
+  }
+
+  getChangeNumber(): Promise<number> {
+    return this.redis.get(this.keys.buildRBSegmentsTillKey()).then((value: string | null) => {
+      const i = parseInt(value as string, 10);
+
+      return isNaNNumber(i) ? -1 : i;
+    }).catch((e) => {
+      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+      return -1;
+    });
+  }
+
+  // @TODO implement if required by DataLoader or producer mode
+  clear() {
+    return Promise.resolve();
+  }
+
+}

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -82,7 +82,8 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
@@ -107,18 +108,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., redis operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
-   * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
+   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
   removeSplit(name: string) {
@@ -127,19 +119,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name));
+      return this.redis.del(this.keys.buildSplitKey(name)).then(status => status === 1);
     });
   }
 
-  /**
-   * Remove a list of splits.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., redis operation fails).
-   */
-  removeSplits(names: string[]): Promise<any> {
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.

package/src/storages/inRedis/index.ts

@@ -11,6 +11,7 @@ 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
@@ -50,6 +51,7 @@ 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/RBSegmentsCachePluggable.ts

@@ -0,0 +1,76 @@
+import { isNaNNumber } from '../../utils/lang';
+import { KeyBuilder } from '../KeyBuilder';
+import { IPluggableStorageWrapper, IRBSegmentsCacheAsync } from '../types';
+import { ILogger } from '../../logger/types';
+import { IRBSegment } from '../../dtos/types';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+
+export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilder;
+  private readonly wrapper: IPluggableStorageWrapper;
+
+  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
+    this.log = log;
+    this.keys = keys;
+    this.wrapper = wrapper;
+  }
+
+  get(name: string): Promise<IRBSegment | null> {
+    return this.wrapper.get(this.keys.buildRBSegmentKey(name))
+      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
+  }
+
+  private getNames(): Promise<string[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildRBSegmentKeyPrefix()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  contains(names: Set<string>): Promise<boolean> {
+    const namesArray = setToArray(names);
+    return this.getNames().then(namesInStorage => {
+      return namesArray.every(name => namesInStorage.includes(name));
+    });
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(toAdd => {
+        const key = this.keys.buildRBSegmentKey(toAdd.name);
+        const stringifiedNewRBSegment = JSON.stringify(toAdd);
+        return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
+      })),
+      Promise.all(toRemove.map(toRemove => {
+        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        return this.wrapper.del(key);
+      }))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
+  setChangeNumber(changeNumber: number) {
+    return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+  }
+
+  getChangeNumber(): Promise<number> {
+    return this.wrapper.get(this.keys.buildRBSegmentsTillKey()).then((value) => {
+      const i = parseInt(value as string, 10);
+
+      return isNaNNumber(i) ? -1 : i;
+    }).catch((e) => {
+      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+      return -1;
+    });
+  }
+
+  // @TODO implement if required by DataLoader or producer mode
+  clear() {
+    return Promise.resolve();
+  }
+
+}

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -66,7 +66,8 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
@@ -91,15 +92,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., wrapper operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
    * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -115,15 +107,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     });
   }
 
-  /**
-   * Remove a list of splits.
-   * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  removeSplits(names: string[]): Promise<void> { // @ts-ignore
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split.
    * The returned promise is resolved with the split definition or null if it's not defined,

package/src/storages/pluggable/index.ts

@@ -20,6 +20,7 @@ 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.';
@@ -116,6 +117,7 @@ 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,