@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.10

package/src/sdkFactory/index.ts

@@ -17,7 +17,7 @@ import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE } from '../utils/constants';
+import { NONE, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -29,7 +29,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
     filterAdapterFactory } = params;
   const log = settings.log;
-  const impressionsMode = settings.sync.impressionsMode;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -52,6 +51,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
     // ATM, only used by PluggableStorage
     mode: settings.mode,
+    impressionsMode: settings.sync.impressionsMode,
 
     // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
     // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
@@ -67,16 +67,26 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
+  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
   const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, filterAdapterFactory && filterAdapterFactory()) : undefined;
-  const strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts!) :
-    (impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!) : strategyDebugFactory(observer);
+  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+
+  let strategy;
+  switch (storageFactoryParams.impressionsMode) {
+    case OPTIMIZED:
+      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
+      break;
+    case NONE:
+      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
+      break;
+    default:
+      strategy = strategyDebugFactory(observer);
+  }
 
   const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);

package/src/sdkManager/index.ts

@@ -18,16 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
-  let splitObject: ISplit | null;
-
-  try {
-    // @ts-expect-error
-    splitObject = JSON.parse(json);
-  } catch (e) {
-    return null;
-  }
-
+function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -40,10 +31,10 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(jsons: string[]) {
+function objectsToViews(splitObjects: ISplit[]) {
   let views: SplitIO.SplitView[] = [];
 
-  jsons.forEach(split => {
+  splitObjects.forEach(split => {
     const view = objectToView(split);
     if (view) views.push(view);
   });

package/src/services/splitApi.ts

@@ -114,7 +114,7 @@ export function splitApiFactory(
      * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
      */
     postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/api/v1/keys/cs`;
+      const url = `${urls.telemetry}/v1/keys/cs`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
     
@@ -125,18 +125,18 @@ export function splitApiFactory(
      * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
      */
     postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/api/v1/keys/ss`;
+      const url = `${urls.telemetry}/v1/keys/ss`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
 
-    postMetricsConfig(body: string) {
+    postMetricsConfig(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/config`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
-    postMetricsUsage(body: string) {
+    postMetricsUsage(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/usage`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     }
   };
 }

package/src/services/types.ts

@@ -51,9 +51,9 @@ export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, s
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsConfig = (body: string) => Promise<IResponse>
+export type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsUsage = (body: string) => Promise<IResponse>
+export type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -7,14 +8,14 @@ import { ISplit } from '../dtos/types';
  */
 export 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>
@@ -40,23 +41,20 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    * The promise will never be rejected.
    */
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
     return this.getSplit(name).then(split => {
 
-      if (split) {
-        const parsedSplit: ISplit = JSON.parse(split);
-        if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-          parsedSplit.killed = true;
-          parsedSplit.defaultTreatment = defaultTreatment;
-          parsedSplit.changeNumber = changeNumber;
-          const newSplit = JSON.stringify(parsedSplit);
+      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+        const newSplit = objectAssign({}, split);
+        newSplit.killed = true;
+        newSplit.defaultTreatment = defaultTreatment;
+        newSplit.changeNumber = changeNumber;
 
-          return this.addSplit(name, newSplit);
-        }
+        return this.addSplit(name, newSplit);
       }
       return false;
     }).catch(() => false);

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -7,9 +8,9 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: string): boolean;
+  abstract addSplit(name: string, split: ISplit): boolean
 
-  addSplits(entries: [string, string][]): boolean[] {
+  addSplits(entries: [string, ISplit][]): boolean[] {
     return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
   }
 
@@ -19,10 +20,10 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return names.map(name => this.removeSplit(name));
   }
 
-  abstract getSplit(name: string): string | null
+  abstract getSplit(name: string): ISplit | null
 
-  getSplits(names: string[]): Record<string, string | null> {
-    const splits: Record<string, string | null> = {};
+  getSplits(names: string[]): Record<string, ISplit | null> {
+    const splits: Record<string, ISplit | null> = {};
     names.forEach(name => {
       splits[name] = this.getSplit(name);
     });
@@ -33,8 +34,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract getChangeNumber(): number
 
-  getAll(): string[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as string);
+  getAll(): ISplit[] {
+    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
   }
 
   abstract getSplitNames(): string[]
@@ -60,22 +61,19 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    */
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
     const split = this.getSplit(name);
 
-    if (split) {
-      const parsedSplit: ISplit = JSON.parse(split);
-      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-        parsedSplit.killed = true;
-        parsedSplit.defaultTreatment = defaultTreatment;
-        parsedSplit.changeNumber = changeNumber;
-        const newSplit = JSON.stringify(parsedSplit);
+    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+      const newSplit = objectAssign({}, split);
+      newSplit.killed = true;
+      newSplit.defaultTreatment = defaultTreatment;
+      newSplit.changeNumber = changeNumber;
 
-        return this.addSplit(name, newSplit);
-      }
+      return this.addSplit(name, newSplit);
     }
     return false;
   }

package/src/storages/KeyBuilderSS.ts

@@ -1,8 +1,9 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
 
-const methodNames: Record<Method, string> = {
+const METHOD_NAMES: Record<Method, string> = {
   t: 'treatment',
   ts: 'treatments',
   tc: 'treatmentWithConfig',
@@ -12,11 +13,17 @@ const methodNames: Record<Method, string> = {
 
 export class KeyBuilderSS extends KeyBuilder {
 
-  protected readonly metadata: IMetadata;
+  latencyPrefix: string;
+  exceptionPrefix: string;
+  initPrefix: string;
+  private versionablePrefix: string;
 
   constructor(prefix: string, metadata: IMetadata) {
     super(prefix);
-    this.metadata = metadata;
+    this.latencyPrefix = `${this.prefix}.telemetry.latencies`;
+    this.exceptionPrefix = `${this.prefix}.telemetry.exceptions`;
+    this.initPrefix = `${this.prefix}.telemetry.init`;
+    this.versionablePrefix = `${metadata.s}/${metadata.n}/${metadata.i}`;
   }
 
   buildRegisteredSegmentsKey() {
@@ -27,6 +34,14 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.impressions`;
   }
 
+  buildImpressionsCountKey() {
+    return `${this.prefix}.impressions.count`;
+  }
+  
+  buildUniqueKeysKey() {
+    return `${this.prefix}.uniquekeys`;
+  }
+
   buildEventsKey() {
     return `${this.prefix}.events`;
   }
@@ -38,19 +53,56 @@ export class KeyBuilderSS extends KeyBuilder {
   /* Telemetry keys */
 
   buildLatencyKey(method: Method, bucket: number) {
-    return `${this.prefix}.telemetry.latencies::${this.buildVersionablePrefix()}/${methodNames[method]}/${bucket}`;
+    return `${this.latencyPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}/${bucket}`;
   }
 
   buildExceptionKey(method: Method) {
-    return `${this.prefix}.telemetry.exceptions::${this.buildVersionablePrefix()}/${methodNames[method]}`;
+    return `${this.exceptionPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}`;
   }
 
   buildInitKey() {
-    return `${this.prefix}.telemetry.init::${this.buildVersionablePrefix()}`;
+    return `${this.initPrefix}::${this.versionablePrefix}`;
   }
 
-  private buildVersionablePrefix() {
-    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
-  }
+}
+
+// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
+
+const REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce((acc, key) => {
+  acc[METHOD_NAMES[key as Method]] = key as Method;
+  return acc;
+}, {} as Record<string, Method>);
+
+
+export function parseMetadata(field: string): [metadata: string] | string {
+  const parts = field.split('/');
+  if (parts.length !== 3) return `invalid subsection count. Expected 3, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */] = parts;
+  return [JSON.stringify({ s, n, i })];
+}
+
+export function parseExceptionField(field: string): [metadata: string, method: Method] | string {
+  const parts = field.split('/');
+  if (parts.length !== 4) return `invalid subsection count. Expected 4, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m] = parts;
+  const method = REVERSE_METHOD_NAMES[m];
+  if (!method) return `unknown method '${m}'`;
+
+  return [JSON.stringify({ s, n, i }), method];
+}
+
+export function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string {
+  const parts = field.split('/');
+  if (parts.length !== 5) return `invalid subsection count. Expected 5, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m, b] = parts;
+  const method = REVERSE_METHOD_NAMES[m];
+  if (!method) return `unknown method '${m}'`;
+
+  const bucket = parseInt(b);
+  if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT) return `invalid bucket. Expected a number between 0 and ${MAX_LATENCY_BUCKET_COUNT - 1}, got: ${b}`;
 
+  return [JSON.stringify({ s, n, i }), method, bucket];
 }

package/src/storages/dataLoader.ts

@@ -39,7 +39,7 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => [splitName, splitsData[splitName]]));
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -38,7 +38,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     else localStorage.removeItem(key);
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: ISplit | null) {
     try {
       if (split) {
         if (split.trafficTypeName) {
@@ -99,18 +99,16 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(name: string, split: string) {
+  addSplit(name: string, split: ISplit) {
     try {
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
       this._decrementCounts(previousSplit);
 
-      localStorage.setItem(splitKey, split);
+      localStorage.setItem(splitKey, JSON.stringify(split));
 
-      const parsedSplit = split ? JSON.parse(split) : null;
-
-      this._incrementCounts(parsedSplit);
+      this._incrementCounts(split);
 
       return true;
     } catch (e) {
@@ -124,8 +122,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const split = this.getSplit(name);
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
-      const parsedSplit = JSON.parse(split as string);
-      this._decrementCounts(parsedSplit);
+      this._decrementCounts(split);
 
       return true;
     } catch (e) {
@@ -135,7 +132,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getSplit(name: string) {
-    return localStorage.getItem(this.keys.buildSplitKey(name));
+    const item = localStorage.getItem(this.keys.buildSplitKey(name));
+    return item && JSON.parse(item);
   }
 
   setChangeNumber(changeNumber: number): boolean {
@@ -184,7 +182,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return n;
   }
 
-  getSplitNames() {
+  getSplitNames(): string[] {
     const len = localStorage.length;
     const accum = [];
 
@@ -231,7 +229,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   /**
    * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-   * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
    *
    * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
    */

package/src/storages/inLocalStorage/index.ts

@@ -12,8 +12,9 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -44,7 +45,8 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
       impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(params.eventsQueueSize),
-      telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
+      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+      uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();
@@ -52,6 +54,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
         this.events.clear();
+        this.uniqueKeys?.clear();
       },
 
       // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,8 +1,16 @@
 import { truncateTimeFrame } from '../../utils/time';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 import { IImpressionCountsCacheSync } from '../types';
 
 export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-  private cache: Record<string, number> = {};
+  protected cache: Record<string, number> = {};
+  private readonly maxStorage: number;
+  protected onFullQueue?: () => void;
+  private cacheSize = 0;
+
+  constructor(impressionCountsCacheSize = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = impressionCountsCacheSize;
+  }
 
   /**
   * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -18,6 +26,13 @@ export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync
     const key = this._makeKey(featureName, timeFrame);
     const currentAmount = this.cache[key];
     this.cache[key] = currentAmount ? currentAmount + amount : amount;
+    if (this.onFullQueue) {
+      this.cacheSize = this.cacheSize + amount;
+      if (this.cacheSize >= this.maxStorage) {
+        this.onFullQueue();
+        this.cacheSize = 0;
+      }
+    }
   }
 
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,8 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
-import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -18,9 +19,10 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     splits: new SplitsCacheInMemory(),
     segments: new SegmentsCacheInMemory(),
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
+    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined, // Always track telemetry in standalone mode on server-side
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -29,6 +31,7 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
+      this.uniqueKeys?.clear();
     }
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,8 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -18,9 +19,10 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     splits: new SplitsCacheInMemory(),
     segments: new MySegmentsCacheInMemory(),
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
+    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -29,6 +31,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
+      this.uniqueKeys?.clear();
     },
 
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -8,7 +8,7 @@ import { isFiniteNumber } from '../../utils/lang';
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
-  private splitsCache: Record<string, string> = {};
+  private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private splitsWithSegmentsCount: number = 0;
@@ -20,10 +20,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsWithSegmentsCount = 0;
   }
 
-  addSplit(name: string, split: string): boolean {
-    const splitFromMemory = this.getSplit(name);
-    if (splitFromMemory) { // We had this Split already
-      const previousSplit: ISplit = JSON.parse(splitFromMemory);
+  addSplit(name: string, split: ISplit): boolean {
+    const previousSplit = this.getSplit(name);
+    if (previousSplit) { // We had this Split already
 
       if (previousSplit.trafficTypeName) {
         const previousTtName = previousSplit.trafficTypeName;
@@ -36,20 +35,18 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
     }
 
-    const parsedSplit: ISplit = JSON.parse(split);
-
-    if (parsedSplit) {
+    if (split) {
       // Store the Split.
       this.splitsCache[name] = split;
       // Update TT cache
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
       if (ttName) { // safeguard
         if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
         this.ttCache[ttName]++;
       }
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount++;
+      if (usesSegments(split)) this.splitsWithSegmentsCount++;
 
       return true;
     } else {
@@ -63,8 +60,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       // Delete the Split
       delete this.splitsCache[name];
 
-      const parsedSplit: ISplit = JSON.parse(split);
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
 
       if (ttName) { // safeguard
         this.ttCache[ttName]--; // Update tt cache
@@ -72,7 +68,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
 
       // Update the segments count.
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount--;
+      if (usesSegments(split)) this.splitsWithSegmentsCount--;
 
       return true;
     } else {
@@ -80,7 +76,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     }
   }
 
-  getSplit(name: string): string | null {
+  getSplit(name: string): ISplit | null {
     return this.splitsCache[name] || null;
   }