@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/src/storages/inMemory/DefinitionsCacheInMemory.ts

@@ -0,0 +1,130 @@
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
+import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
+import { isFiniteNumber } from '../../utils/lang';
+
+/**
+ * Default IDefinitionsCacheSync implementation that stores split definitions in memory.
+ */
+export class DefinitionsCacheInMemory extends AbstractDefinitionsCacheSync {
+
+  private setsFilter: string[];
+  private definitionsCache: Record<string, IDefinition> = {};
+  private ttCache: Record<string, number> = {};
+  private changeNumber: number = -1;
+  private segmentsCount: number = 0;
+  private setsCache: Record<string, Set<string>> = {};
+
+  constructor(splitFiltersValidation?: ISplitFiltersValidation) {
+    super();
+    this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+  }
+
+  clear() {
+    this.definitionsCache = {};
+    this.ttCache = {};
+    this.changeNumber = -1;
+    this.segmentsCount = 0;
+    this.setsCache = {};
+  }
+
+  add(definition: IDefinition): boolean {
+    const name = definition.name;
+    const previousDefinition = this.get(name);
+    if (previousDefinition) { // We had this Split already
+
+      const previousTtName = previousDefinition.trafficTypeName;
+      this.ttCache[previousTtName]--;
+      if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
+
+      this.removeFromFlagSets(previousDefinition.name, previousDefinition.sets);
+
+      // Subtract from segments count for the previous version of this Split
+      if (usesSegments(previousDefinition)) this.segmentsCount--;
+    }
+
+    // Store the Split.
+    this.definitionsCache[name] = definition;
+    // Update TT cache
+    const ttName = definition.trafficTypeName;
+    this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+    this.addToFlagSets(definition);
+
+    // Add to segments count for the new version of the Split
+    if (usesSegments(definition)) this.segmentsCount++;
+
+    return true;
+  }
+
+  remove(name: string): boolean {
+    const definition = this.get(name);
+    if (!definition) return false;
+
+    // Delete the Split
+    delete this.definitionsCache[name];
+
+    const ttName = definition.trafficTypeName;
+    this.ttCache[ttName]--; // Update tt cache
+    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+    this.removeFromFlagSets(definition.name, definition.sets);
+
+    // Update the segments count.
+    if (usesSegments(definition)) this.segmentsCount--;
+
+    return true;
+  }
+
+  get(name: string): IDefinition | null {
+    return this.definitionsCache[name] || null;
+  }
+
+  setChangeNumber(changeNumber: number): boolean {
+    this.changeNumber = changeNumber;
+    return true;
+  }
+
+  getChangeNumber(): number {
+    return this.changeNumber;
+  }
+
+  getNames(): string[] {
+    return Object.keys(this.definitionsCache);
+  }
+
+  trafficTypeExists(trafficType: string): boolean {
+    return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
+  }
+
+  usesSegments(): boolean {
+    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+  }
+
+  getNamesBySets(sets: string[]): Set<string>[] {
+    return sets.map(set => this.setsCache[set] || new Set());
+  }
+
+  private addToFlagSets(featureFlag: IDefinition) {
+    if (!featureFlag.sets) return;
+    featureFlag.sets.forEach(featureFlagSet => {
+
+      if (this.setsFilter.length > 0 && !this.setsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
+
+      if (!this.setsCache[featureFlagSet]) this.setsCache[featureFlagSet] = new Set([]);
+
+      this.setsCache[featureFlagSet].add(featureFlag.name);
+    });
+  }
+
+  private removeFromFlagSets(featureFlagName: string, sets?: string[] | null) {
+    if (!sets) return;
+    sets.forEach(set => {
+      this.removeNames(set, featureFlagName);
+    });
+  }
+
+  private removeNames(setName: string, featureFlagName: string) {
+    if (!this.setsCache[setName]) return;
+    this.setsCache[setName].delete(featureFlagName);
+    if (this.setsCache[setName].size === 0) delete this.setsCache[setName];
+  }
+
+}

package/src/storages/inMemory/InMemoryStorage.ts

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -17,18 +17,18 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new SegmentsCacheInMemory();
 
   const storage = {
-    splits,
+    definitions,
     rbSegments,
     segments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: new ImpressionCountsCacheInMemory(),
     events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
     uniqueKeys: new UniqueKeysCacheInMemory(),
 
     destroy() { }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -17,20 +17,20 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
   const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
   const rbSegments = new RBSegmentsCacheInMemory();
   const segments = new MySegmentsCacheInMemory();
   const largeSegments = new MySegmentsCacheInMemory();
 
   const storage = {
-    splits,
+    definitions,
     rbSegments,
     segments,
     largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: new ImpressionCountsCacheInMemory(),
     events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
     uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
     destroy() { },
@@ -38,7 +38,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {
-        splits: this.splits,
+        definitions: this.definitions,
         rbSegments: this.rbSegments,
         segments: new MySegmentsCacheInMemory(),
         largeSegments: new MySegmentsCacheInMemory(),

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -1,6 +1,6 @@
 import { IRBSegment } from '../../dtos/types';
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
+import { usesSegments } from '../AbstractDefinitionsCacheSync';
 import { IRBSegmentsCacheSync } from '../types';
 
 export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
@@ -15,9 +15,9 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     this.segmentsCount = 0;
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean {
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
     this.changeNumber = changeNumber;
     return updated;
   }

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -2,7 +2,7 @@ import { isIntegerNumber } from '../../utils/lang';
 import { ISegmentsCacheSync } from '../types';
 
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default IDefinitionsCacheSync implementation for server-side that stores segments definitions in memory.
  */
 export class SegmentsCacheInMemory implements ISegmentsCacheSync {
 

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -2,7 +2,7 @@ import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies,
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { checkIfServerSide } from '../../utils/key';
 import { findLatencyIndex } from '../findLatencyIndex';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ISegmentsCacheSync, IDefinitionsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
 const MAX_STREAMING_EVENTS = 20;
 const MAX_TAGS = 10;
@@ -20,15 +20,15 @@ const ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
-  return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
+export function shouldRecordTelemetry({ settings, disableTelemetry }: IStorageFactoryParams) {
+  return !disableTelemetry && settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   public name = 'telemetry stats';
 
-  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
+  constructor(private definitions?: IDefinitionsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
 
   // isEmpty flag
   private e = true;
@@ -51,7 +51,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       iQ: this.getImpressionStats(QUEUED),
       iDe: this.getImpressionStats(DEDUPED),
       iDr: this.getImpressionStats(DROPPED),
-      spC: this.splits && this.splits.getSplitNames().length,
+      spC: this.definitions && this.definitions.getNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
       lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,

package/src/storages/inRedis/{SplitsCacheInRedis.ts → DefinitionsCacheInRedis.ts}

@@ -2,8 +2,8 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
 import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
@@ -18,23 +18,23 @@ function processPipelineAnswer(results: Array<[Error | null, unknown]> | null):
 }
 
 /**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
+ * IDefinitionsCacheAsync implementation that stores definitions in Redis.
  * Supported by Node.js
  */
-export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
+export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
 
   private readonly log: ILogger;
   private readonly redis: RedisAdapter;
   private readonly keys: KeyBuilderSS;
   private redisError?: Error;
-  private readonly flagSetsFilter: string[];
+  private readonly setsFilter: string[];
 
   constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation) {
     super();
     this.log = log;
     this.redis = redis;
     this.keys = keys;
-    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+    this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
 
     // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
     // But it is done just to avoid getting the ioredis message `Unhandled error event`.
@@ -47,95 +47,95 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     });
   }
 
-  private _decrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+  private _decrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
     return this.redis.decr(ttKey).then((count: number) => {
       if (count === 0) return this.redis.del(ttKey);
     });
   }
 
-  private _incrementCounts(split: ISplit) {
-    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+  private _incrementCounts(definition: IDefinition) {
+    const ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
     return this.redis.incr(ttKey);
   }
 
-  private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+  private _updateSets(definitionName: string, setsOfRemovedDefinition?: string[] | null, setsOfAddedDefinition?: string[] | null) {
+    const removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
 
-    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-    if (this.flagSetsFilter.length > 0) {
-      addToFlagSets = addToFlagSets.filter(flagSet => {
-        return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);
+    let addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+    if (this.setsFilter.length > 0) {
+      addToSets = addToSets.filter(set => {
+        return this.setsFilter.some(filterSet => filterSet === set);
       });
     }
 
-    const items = [featureFlagName];
+    const items = [definitionName];
 
     return Promise.all([
-      ...removeFromFlagSets.map(flagSetName => this.redis.srem(this.keys.buildFlagSetKey(flagSetName), items)),
-      ...addToFlagSets.map(flagSetName => this.redis.sadd(this.keys.buildFlagSetKey(flagSetName), items))
+      ...removeFromSets.map(setName => this.redis.srem(this.keys.buildSetKey(setName), items)),
+      ...addToSets.map(setName => this.redis.sadd(this.keys.buildSetKey(setName), items))
     ]);
   }
 
   /**
-   * Add a given split.
+   * Add a given definition.
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(split: ISplit): Promise<boolean> {
-    const name = split.name;
-    const splitKey = this.keys.buildSplitKey(name);
-    return this.redis.get(splitKey).then((splitFromStorage: string | null) => {
+  add(definition: IDefinition): Promise<boolean> {
+    const name = definition.name;
+    const definitionKey = this.keys.buildDefinitionKey(name);
+    return this.redis.get(definitionKey).then((definitionFromStorage: string | null) => {
 
       // handling parsing error
-      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
+      let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
       try {
-        parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        stringifiedNewSplit = JSON.stringify(split);
+        parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        stringifiedNewDefinition = JSON.stringify(definition);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return this.redis.set(splitKey, stringifiedNewSplit).then(() => {
+      return this.redis.set(definitionKey, stringifiedNewDefinition).then(() => {
         // avoid unnecessary increment/decrement operations
-        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
+        if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
 
         // update traffic type counts
-        return this._incrementCounts(split).then(() => {
-          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
+        return this._incrementCounts(definition).then(() => {
+          if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
         });
-      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
     }).then(() => true);
   }
 
   /**
-   * Remove a given split.
-   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
+   * Remove a given definition.
+   * The returned promise is resolved when the operation success, with true or false indicating if the definition existed (and was removed) or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
-  removeSplit(name: string) {
-    return this.getSplit(name).then((split) => {
-      if (split) {
-        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
+  remove(name: string) {
+    return this.get(name).then((definition) => {
+      if (definition) {
+        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name)).then((status: number) => status === 1);
+      return this.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
     });
   }
 
   /**
-   * Get split definition or null if it's not defined.
+   * Get definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplit(name: string): Promise<ISplit | null> {
+  get(name: string): Promise<IDefinition | null> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    return this.redis.get(this.keys.buildSplitKey(name))
-      .then((maybeSplit: string | null) => maybeSplit && JSON.parse(maybeSplit));
+    return this.redis.get(this.keys.buildDefinitionKey(name))
+      .then((maybeDefinition: string | null) => maybeDefinition && JSON.parse(maybeDefinition));
   }
 
   /**
@@ -144,7 +144,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * or rejected if it fails.
    */
   setChangeNumber(changeNumber: number): Promise<boolean> {
-    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(
+    return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(
       (status: string | null) => status === 'OK'
     );
   }
@@ -155,7 +155,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The promise will never be rejected.
    */
   getChangeNumber(): Promise<number> {
-    return this.redis.get(this.keys.buildSplitsTillKey()).then((value: string | null) => {
+    return this.redis.get(this.keys.buildDefinitionsTillKey()).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
       return isNaNNumber(i) ? -1 : i;
@@ -166,44 +166,44 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Get list of all split definitions.
-   * The returned promise is resolved with the list of split definitions,
+   * Get list of all definitions.
+   * The returned promise is resolved with the list of definitions,
    * or rejected if redis operation fails.
    */
   // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
-  getAll(): Promise<ISplit[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys())
+  getAll(): Promise<IDefinition[]> {
+    return this.redis.keys(this.keys.searchPatternForDefinitionKeys())
       .then((listOfKeys: string[]) => this.redis.pipeline(listOfKeys.map((k: string) => ['get', k])).exec())
       .then(processPipelineAnswer)
-      .then((splitDefinitions: string[]) => splitDefinitions.map((splitDefinition: string) => {
-        return JSON.parse(splitDefinition);
+      .then((definitions: string[]) => definitions.map((definition: string) => {
+        return JSON.parse(definition);
       }));
   }
 
   /**
-   * Get list of split names.
-   * The returned promise is resolved with the list of split names,
+   * Get list of definition names.
+   * The returned promise is resolved with the list of names,
    * or rejected if redis operation fails.
    */
-  getSplitNames(): Promise<string[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
+  getNames(): Promise<string[]> {
+    return this.redis.keys(this.keys.searchPatternForDefinitionKeys()).then(
       (listOfKeys: string[]) => listOfKeys.map(this.keys.extractKey)
     );
   }
 
   /**
-   * Get list of feature flag names related to a given list of flag set names.
-   * The returned promise is resolved with the list of feature flag names per flag set,
+   * Get list of definition names related to a given list of set names.
+   * The returned promise is resolved with the list of names per set,
    * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
-    return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
+  getNamesBySets(sets: string[]): Promise<Set<string>[]> {
+    return this.redis.pipeline(sets.map(set => ['smembers', this.keys.buildSetKey(set)])).exec()
       .then((results: [Error | null, unknown][] | null) => results ? results.map(([e, value]: [Error | null, unknown], index: number) => {
         if (e === null) return value as string;
 
-        this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
+        this.log.error(LOG_PREFIX + `Could not read result from get members of set ${sets[index]} due to an error: ${e}`);
       }) : [])
-      .then((namesByFlagSets: (string | undefined)[]) => namesByFlagSets.map((namesByFlagSet: string | undefined) => new Set(namesByFlagSet)));
+      .then((namesBySets: (string | undefined)[]) => namesBySets.map((namesBySet: string | undefined) => new Set(namesBySet)));
   }
 
   /**
@@ -239,25 +239,25 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   /**
-   * Fetches multiple splits definitions.
+   * Fetches multiple definitions.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
+  getMany(names: string[]): Promise<Record<string, IDefinition | null>> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    const keys = names.map(name => this.keys.buildSplitKey(name));
+    const keys = names.map(name => this.keys.buildDefinitionKey(name));
     return this.redis.mget(...keys)
-      .then((splitDefinitions: (string | null)[]) => {
-        const splits: Record<string, ISplit | null> = {};
+      .then((stringifiedDefinitions: (string | null)[]) => {
+        const definitions: Record<string, IDefinition | null> = {};
         names.forEach((name, idx) => {
-          const split = splitDefinitions[idx];
-          splits[name] = split && JSON.parse(split);
+          const definition = stringifiedDefinitions[idx];
+          definitions[name] = definition && JSON.parse(definition);
         });
-        return Promise.resolve(splits);
+        return Promise.resolve(definitions);
       })
       .catch((e: unknown) => {
         this.log.error(LOG_PREFIX + `Could not grab feature flags due to an error: ${e}.`);

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -37,7 +37,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -46,7 +46,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
         return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
       })),
       Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        const key = this.keys.buildRBSegmentKey(toRemove);
         return this.redis.del(key).then((status: number) => status === 1);
       }))
     ]).then(([, added, removed]) => {

package/src/storages/inRedis/index.ts

@@ -2,7 +2,7 @@ import type { RedisAdapter } from './RedisAdapter';
 import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCacheInRedis } from './SplitsCacheInRedis';
+import { DefinitionsCacheInRedis } from './DefinitionsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
@@ -59,7 +59,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
     });
 
     return {
-      splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+      definitions: new DefinitionsCacheInRedis(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),