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

package/src/sync/submitters/submitterManager.ts

@@ -4,7 +4,6 @@ import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
-import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 
 export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
@@ -16,7 +15,6 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
-  if (params.uniqueKeysTracker) submitters.push(uniqueKeysSubmitterFactory(params));
 
   return {
     // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -52,9 +52,8 @@ const OPERATION_MODE_MAP = {
 
 const IMPRESSIONS_MODE_MAP = {
   [OPTIMIZED]: OPTIMIZED_ENUM,
-  [DEBUG]: DEBUG_ENUM,
-  [NONE]: NONE_ENUM
-} as Record<ISettings['sync']['impressionsMode'], (0 | 1 | 2)>;
+  [DEBUG]: DEBUG_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
 
 const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,

package/src/sync/submitters/types.ts

@@ -35,24 +35,6 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
-export type UniqueKeysPayloadSs = {
-  keys: {
-    /** Split name */
-    f: string
-    /** keyNames */
-    ks: string[]
-  }[]
-}
-
-export type UniqueKeysPayloadCs = {
-  keys: {
-    /** keyNames */
-    k: string
-    /** Split name */
-    fs: string[]
-  }[]
-}
-
 export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
@@ -166,8 +148,7 @@ export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_E
 
 export type OPTIMIZED_ENUM = 0;
 export type DEBUG_ENUM = 1;
-export type NONE_ENUM = 2;
-export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits

package/src/trackers/impressionsTracker.ts

@@ -1,8 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
+import { truncateTimeFrame } from '../utils/time';
+import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { IImpressionObserver } from './impressionObserver/types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 
@@ -13,14 +15,18 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
+ * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
 export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
-  strategy: IStrategy,
   integrationsManager?: IImpressionsHandler,
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
+  // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
+  observer?: IImpressionObserver,
+  // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
+  countsCache?: IImpressionCountsCacheSync,
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IImpressionsTracker {
 
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
@@ -30,36 +36,51 @@ export function impressionsTrackerFactory(
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
-      const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
-      const impressionsToListenerCount = impressionsToListener.length;
-      
-      if ( impressionsToStore.length>0 ){
-        const res = impressionsCache.track(impressionsToStore);
 
-        // If we're on an async storage, handle error and log it.
-        if (thenable(res)) {
-          res.then(() => {
-            log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-          }).catch(err => {
-            log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-          });
-        } else {
-          // Record when impressionsCache is sync only (standalone mode)
-          // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-          if (telemetryCache) {
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
-          }
+      const impressionsToStore: ImpressionDTO[] = []; // Track only the impressions that are going to be stored
+      // Wraps impressions to store and adds previousTime if it corresponds
+      impressions.forEach((impression) => {
+        if (observer) {
+          // Adds previous time if it is enabled
+          impression.pt = observer.testAndSet(impression);
+        }
+
+        const now = Date.now();
+        if (countsCache) {
+          // Increments impression counter per featureName
+          countsCache.track(impression.feature, now, 1);
+        }
+
+        // Checks if the impression should be added in queue to be sent
+        if (!countsCache || !impression.pt || impression.pt < truncateTimeFrame(now)) {
+          impressionsToStore.push(impression);
+        }
+      });
+
+      const res = impressionsCache.track(impressionsToStore);
+
+      // If we're on an async storage, handle error and log it.
+      if (thenable(res)) {
+        res.then(() => {
+          log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+        }).catch(err => {
+          log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+        });
+      } else {
+        // Record when impressionsCache is sync only (standalone mode)
+        // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+        if (telemetryCache) {
+          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
+          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
         }
       }
 
       // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
       if (impressionListener || integrationsManager) {
-        for (let i = 0; i < impressionsToListenerCount; i++) {
+        for (let i = 0; i < impressionsCount; i++) {
           const impressionData: SplitIO.ImpressionData = {
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-            impression: objectAssign({}, impressionsToListener[i]),
+            impression: objectAssign({}, impressions[i]),
             attributes,
             ip,
             hostname,

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,30 +41,8 @@ export interface ITelemetryTracker {
    * Records streaming event
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
-}
-
-export interface IFilterAdapter {
-  add(key: string, featureName: string): boolean;
-  contains(key: string, featureName: string): boolean;
-  clear(): void;
-}
-
-export interface IImpressionSenderAdapter {
-  recordUniqueKeys(data: Object): void;
-  recordImpressionCounts(data: Object): void
-}
-
-/** Unique keys tracker */
-export interface IUniqueKeysTracker {
-  track(key: string, featureName: string): void;
-}
-
-export interface IStrategyResult {
-  impressionsToStore: ImpressionDTO[],
-  impressionsToListener: ImpressionDTO[],
-  deduped: number
-}
-
-export interface IStrategy {
-  process(impressions:  ImpressionDTO[]): IStrategyResult
+  /**
+   * Records tag
+   */
+  addTag(tag: string): void
 }

package/src/types.ts

@@ -80,8 +80,6 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
-    uniqueKeysRefreshRate: number,
-    uniqueKeysCacheSize: number,
     /**
      * @deprecated
      */
@@ -720,7 +718,7 @@ export namespace SplitIO {
   * ImpressionsMode type
   * @typedef {string} ImpressionsMode
   */
-  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE'
+  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG'
   /**
    * Defines the format of Split data to preload on the factory storage (cache).
    */

package/src/utils/constants/index.ts

@@ -19,7 +19,6 @@ export const SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export const DEBUG = 'DEBUG';
 export const OPTIMIZED = 'OPTIMIZED';
-export const NONE = 'NONE';
 
 // SDK Modes
 export const LOCALHOST_MODE: SDKMode = 'localhost';
@@ -50,7 +49,6 @@ export const CONSUMER_PARTIAL_ENUM = 2;
 
 export const OPTIMIZED_ENUM = 0;
 export const DEBUG_ENUM = 1;
-export const NONE_ENUM = 2;
 
 export const SPLITS = 'sp';
 export const IMPRESSIONS = 'im';

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,14 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 
 export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
   impressionsMode = stringToUpperCase(impressionsMode);
 
-  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
+  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
 
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
   return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -36,8 +36,6 @@ export const base = {
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
     impressionsRefreshRate: 300,
-    // publish unique Keys each 900 sec (15 min) 
-    uniqueKeysRefreshRate: 900,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -132,13 +130,11 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-  scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
   if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
-  
 
   // Log deprecation for old telemetry param
   if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');

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/logger/constants.d.ts

@@ -138,5 +138,4 @@ export declare const LOG_PREFIX_SYNC_POLLING: string;
 export declare const LOG_PREFIX_SYNC_SUBMITTERS: string;
 export declare const LOG_PREFIX_IMPRESSIONS_TRACKER = "impressions-tracker: ";
 export declare const LOG_PREFIX_EVENTS_TRACKER = "events-tracker: ";
-export declare const LOG_PREFIX_UNIQUE_KEYS_TRACKER = "unique-keys-tracker: ";
 export declare const LOG_PREFIX_CLEANUP = "cleanup: ";

package/types/sdkFactory/types.d.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
@@ -42,7 +42,6 @@ export interface ISdkFactoryContext {
     eventTracker: IEventTracker;
     telemetryTracker: ITelemetryTracker;
     storage: IStorageSync | IStorageAsync;
-    uniqueKeysTracker?: IUniqueKeysTracker;
     signalListener?: ISignalListener;
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
@@ -71,12 +70,11 @@ export interface ISdkFactoryParams {
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
-    impressionsObserverFactory: () => IImpressionObserver;
-    filterAdapterFactory?: () => IFilterAdapter;
     SignalListener?: new (syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
+    impressionsObserverFactory?: () => IImpressionObserver;
     extraProps?: (params: ISdkFactoryContext) => object;
 }

package/types/services/types.d.ts

@@ -20,8 +20,6 @@ export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
@@ -34,8 +32,6 @@ export interface ISplitApi {
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
-    postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
-    postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
     postMetricsConfig: IPostMetricsConfig;

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/KeyBuilderSS.d.ts

@@ -6,8 +6,6 @@ export declare class KeyBuilderSS extends KeyBuilder {
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;
-    buildImpressionsCountKey(): string;
-    buildUniqueKeysKey(): string;
     buildEventsKey(): string;
     searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;

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/ImpressionCountsCacheInMemory.d.ts

@@ -1,10 +1,6 @@
 import { IImpressionCountsCacheSync } from '../types';
 export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-    protected cache: Record<string, number>;
-    private readonly maxStorage;
-    protected onFullQueue?: () => void;
-    private cacheSize;
-    constructor(impressionCountsCacheSize?: number);
+    private cache;
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */

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/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/constants.d.ts

@@ -1,4 +1 @@
 export declare const LOG_PREFIX = "storage:redis: ";
-export declare const DEFAULT_CACHE_SIZE = 30000;
-export declare const REFRESH_RATE = 300000;
-export declare const TTL_REFRESH = 3600;

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,