@splitsoftware/splitio-commons 1.6.2-rc.5 → 1.6.2-rc.8

package/src/storages/inRedis/uniqueKeysCacheInRedis.ts

@@ -11,20 +11,22 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
   private readonly log: ILogger;
   private readonly key: string;
   private readonly redis: Redis;
-  private handle: any;
+  private readonly refreshRate: number;
+  private intervalId: any;
   
-  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
+  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE, refreshRate: number = REFRESH_RATE) {
     super(uniqueKeysQueueSize);
     this.log = log;
     this.key = key;
     this.redis = redis;
+    this.refreshRate = refreshRate;
     this.onFullQueue = () => {this.postUniqueKeysInRedis();};
   }
   
   postUniqueKeysInRedis() {
-    const pipeline = this.redis.pipeline();
-    
     const featureNames = Object.keys(this.uniqueKeysTracker);
+    if (!featureNames) return Promise.resolve(false);
+    const pipeline = this.redis.pipeline();
     for (let i = 0; i < featureNames.length; i++) {
       const featureName = featureNames[i];
       const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
@@ -45,17 +47,18 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
       })
       .catch(err => {
         this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
-        return false;
+        return Promise.resolve(false);
       });
   }
   
     
-  start(refreshRate: number = REFRESH_RATE) {
-    this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+  start() {
+    this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
   }
   
   stop() {
-    clearInterval(this.handle);
+    clearInterval(this.intervalId);
+    return this.postUniqueKeysInRedis();
   }
   
 }

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -49,22 +49,22 @@ 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: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.wrapper.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.wrapper.set(splitKey, stringifiedNewSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type and segment count of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -76,7 +76,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -88,8 +88,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
@@ -109,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name));
+  getSplit(name: string): Promise<ISplit | null> {
+    return this.wrapper.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -118,13 +118,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, string | null> = {};
+      const splits: Record<string, ISplit | null> = {};
       names.forEach((name, idx) => {
-        splits[name] = splitDefinitions[idx];
+        const split = splitDefinitions[idx];
+        splits[name] = split && JSON.parse(split);
       });
       return Promise.resolve(splits);
     });
@@ -135,10 +136,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => Promise.all(listOfKeys.map(this.wrapper.get) as Promise<string>[])
-    );
+  getAll(): Promise<ISplit[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**

package/src/storages/types.ts

@@ -1,4 +1,4 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
@@ -191,14 +191,14 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
   removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
-  getSplit(name: string): MaybeThenable<string | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, string | null>>, // `fetchMany` in spec
+  getSplit(name: string): MaybeThenable<ISplit | null>,
+  getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
   setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<string[]>,
+  getAll(): MaybeThenable<ISplit[]>,
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
@@ -211,13 +211,13 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): boolean[],
+  addSplits(entries: [string, ISplit][]): boolean[],
   removeSplits(names: string[]): boolean[],
-  getSplit(name: string): string | null,
-  getSplits(names: string[]): Record<string, string | null>,
+  getSplit(name: string): ISplit | null,
+  getSplits(names: string[]): Record<string, ISplit | null>,
   setChangeNumber(changeNumber: number): boolean,
   getChangeNumber(): number,
-  getAll(): string[],
+  getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
@@ -227,13 +227,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): Promise<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
   removeSplits(names: string[]): Promise<boolean[] | void>,
-  getSplit(name: string): Promise<string | null>,
-  getSplits(names: string[]): Promise<Record<string, string | null>>,
+  getSplit(name: string): Promise<ISplit | null>,
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
   setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<string[]>,
+  getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -2,7 +2,7 @@ import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
-import { ISplitPartial } from '../../../dtos/types';
+import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, string][] = [];
+    const splits: [string, ISplit][] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -38,9 +38,8 @@ export function fromObjectUpdaterFactory(
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
       forOwn(splitsMock, function (val, name) {
-        splits.push([
-          name,
-          JSON.stringify({
+        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+          name, {
             name,
             status: 'ACTIVE',
             killed: false,
@@ -49,7 +48,7 @@ export function fromObjectUpdaterFactory(
             conditions: val.conditions || [],
             configurations: val.configurations,
             trafficTypeName: val.trafficTypeName
-          })
+          }
         ]);
       });
 

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

@@ -40,7 +40,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
 }
 
 interface ISplitMutations {
-  added: [string, string][],
+  added: [string, ISplit][],
   removed: string[],
   segments: string[]
 }
@@ -54,7 +54,7 @@ export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE') {
-      accum.added.push([split.name, JSON.stringify(split)]);
+      accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);

package/src/trackers/strategy/strategyOptimized.ts

@@ -25,7 +25,7 @@ export function strategyOptimizedFactory(
         const now = Date.now();
         
         // Increments impression counter per featureName
-        impressionsCounter.track(impression.feature, now, 1);
+        if (impression.pt) impressionsCounter.track(impression.feature, now, 1);
   
         // Checks if the impression should be added in queue to be sent
         if (!impression.pt || impression.pt < truncateTimeFrame(now)) {

package/src/trackers/telemetryTracker.ts

@@ -48,6 +48,10 @@ export function telemetryTrackerFactory(
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }
+      },
+      addTag(tag: string) {
+        // @ts-ignore
+        if (telemetryCache.addTag) telemetryCache.addTag(tag);
       }
     };
 
@@ -56,8 +60,9 @@ export function telemetryTrackerFactory(
     return {
       trackEval: noopTrack,
       trackHttp: noopTrack,
-      sessionLength: () => { },
-      streamingEvent: () => { },
+      sessionLength() { },
+      streamingEvent() { },
+      addTag() { }
     };
   }
 }

package/src/trackers/types.ts

@@ -41,12 +41,17 @@ export interface ITelemetryTracker {
    * Records streaming event
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
+  /**
+   * Records tag
+   */
+  addTag(tag: string): void
 }
 
 export interface IFilterAdapter {
   add(key: string, featureName: string): boolean;
   contains(key: string, featureName: string): boolean;
   clear(): void;
+  refreshRate?: number;
 }
 
 export interface IImpressionSenderAdapter {
@@ -56,6 +61,7 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+  stop(): void;
   track(key: string, featureName: string): void;
 }
 

package/src/trackers/uniqueKeysTracker.ts

@@ -15,23 +15,34 @@ const noopFilterAdapter = {
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post. 
  * 
  * @param log Logger instance
- * @param filterAdapter filter adapter
  * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
  */
 export function uniqueKeysTrackerFactory(
   log: ILogger,
   uniqueKeysCache: IUniqueKeysCacheBase,
   filterAdapter: IFilterAdapter = noopFilterAdapter,
 ): IUniqueKeysTracker {
-  
+  let intervalId: any;
+
+  if (filterAdapter.refreshRate) {
+    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+  }
+
   return {
+
     track(key: string, featureName: string): void {
       if (!filterAdapter.add(key, featureName)) {
         log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The feature ${featureName} and key ${key} exist in the filter`);
         return;
       }
       uniqueKeysCache.track(key, featureName);
+    },
+
+    stop(): void {
+      clearInterval(intervalId);
     }
+    
   };
 
 }

package/types/integrations/types.d.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 export interface IIntegration {
     queue(data: SplitIO.IntegrationData): void;
@@ -10,6 +10,7 @@ export interface IIntegrationFactoryParams {
         events: IEventsCacheBase;
     };
     settings: ISettings;
+    telemetryTracker: ITelemetryTracker;
 }
 export declare type IntegrationFactory = {
     readonly type: string;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,17 +1,18 @@
 import { ISplitsCacheAsync } from './types';
+import { ISplit } from '../dtos/types';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-    abstract addSplit(name: string, split: string): Promise<boolean>;
-    abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    abstract addSplit(name: string, split: ISplit): Promise<boolean>;
+    abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;
-    abstract getSplit(name: string): Promise<string | null>;
-    abstract getSplits(names: string[]): Promise<Record<string, string | null>>;
+    abstract getSplit(name: string): Promise<ISplit | null>;
+    abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     abstract setChangeNumber(changeNumber: number): Promise<boolean | void>;
     abstract getChangeNumber(): Promise<number>;
-    abstract getAll(): Promise<string[]>;
+    abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -5,15 +5,15 @@ import { ISplit } from '../dtos/types';
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-    abstract addSplit(name: string, split: string): boolean;
-    addSplits(entries: [string, string][]): boolean[];
+    abstract addSplit(name: string, split: ISplit): boolean;
+    addSplits(entries: [string, ISplit][]): boolean[];
     abstract removeSplit(name: string): boolean;
     removeSplits(names: string[]): boolean[];
-    abstract getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    abstract getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     abstract setChangeNumber(changeNumber: number): boolean;
     abstract getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
@@ -26,9 +26,9 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
      */
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): any;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -1,3 +1,4 @@
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -9,9 +10,9 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private changeNumber;
     private splitsWithSegmentsCount;
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): ISplit | null;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

package/types/storages/inRedis/ImpressionCountsCacheInRedis.d.ts

@@ -5,9 +5,10 @@ export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheI
     private readonly log;
     private readonly key;
     private readonly redis;
-    private handle;
-    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number);
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
     postImpressionCountsInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
-    start(refreshRate?: number): void;
-    stop(): void;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
 }

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -19,13 +20,13 @@ export declare 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: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * 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, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
@@ -42,7 +43,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Set till number.
      * The returned promise is resolved when the operation success,
@@ -63,7 +64,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * @TODO we need to benchmark which is the maximun number of commands we could
      *       pipeline without kill redis performance.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,
@@ -87,5 +88,5 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
 }

package/types/storages/inRedis/uniqueKeysCacheInRedis.d.ts

@@ -6,9 +6,10 @@ export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory impl
     private readonly log;
     private readonly key;
     private readonly redis;
-    private handle;
-    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number);
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
     postUniqueKeysInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
-    start(refreshRate?: number): void;
-    stop(): void;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
 }

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -23,13 +24,13 @@ export declare 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: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * 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, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -47,19 +48,19 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Get list of splits.
      * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     /**
      * Get list of all split definitions.
      * The returned promise is resolved with the list of split definitions,
      * or rejected if wrapper operation fails.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,

package/types/storages/types.d.ts

@@ -1,4 +1,4 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
@@ -178,13 +178,13 @@ export interface IPluggableStorageWrapper {
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
-    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>;
     removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    getSplit(name: string): MaybeThenable<string | null>;
-    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
+    getSplit(name: string): MaybeThenable<ISplit | null>;
+    getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(): MaybeThenable<number>;
-    getAll(): MaybeThenable<string[]>;
+    getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
@@ -193,13 +193,13 @@ export interface ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): boolean[];
+    addSplits(entries: [string, ISplit][]): boolean[];
     removeSplits(names: string[]): boolean[];
-    getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
@@ -208,13 +208,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     removeSplits(names: string[]): Promise<boolean[] | void>;
-    getSplit(name: string): Promise<string | null>;
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplit(name: string): Promise<ISplit | null>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): Promise<boolean | void>;
     getChangeNumber(): Promise<number>;
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;