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

package/esm/storages/inMemory/uniqueKeysCacheInMemory.js

@@ -0,0 +1,70 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+var DEFAULT_CACHE_SIZE = 30000;
+var UniqueKeysCacheInMemory = /** @class */ (function () {
+    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = feature name.
+     * value: Set<string> = set of unique keys.
+     */
+    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[featureName])
+            this.uniqueKeysTracker[featureName] = new _Set();
+        var tracker = this.uniqueKeysTracker[featureName];
+        if (!tracker.has(key)) {
+            tracker.add(key);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemory.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemory.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload for SS.
+     */
+    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var featureNames = Object.keys(uniqueKeys);
+        for (var i = 0; i < featureNames.length; i++) {
+            var featureName = featureNames[i];
+            var featureKeys = setToArray(uniqueKeys[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemory;
+}());
+export { UniqueKeysCacheInMemory };

package/esm/storages/inMemory/uniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,75 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+var DEFAULT_CACHE_SIZE = 30000;
+var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = key.
+     * value: HashSet<string> = set of split names.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[key])
+            this.uniqueKeysTracker[key] = new _Set();
+        var tracker = this.uniqueKeysTracker[key];
+        if (!tracker.has(featureName)) {
+            tracker.add(featureName);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var featureKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < featureKeys.length; k++) {
+            var featureKey = featureKeys[k];
+            var featureNames = setToArray(uniqueKeys[featureKey]);
+            var uniqueKeysPayload = {
+                k: featureKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+export { UniqueKeysCacheInMemoryCS };

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,6 +1,6 @@
 var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-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 { 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 { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
@@ -46,6 +46,7 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
+    _b[NONE] = NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[CONSENT_UNKNOWN] = 1,

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -1,57 +1,6 @@
-import { setToArray } from '../../utils/lang/sets';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { submitterFactory } from './submitter';
-/**
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys) {
-    var featureNames = Object.keys(uniqueKeys);
-    var inverted = {};
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        for (var j = 0; j < featureKeys.length; j++) {
-            var featureKey = featureKeys[j];
-            if (!inverted[featureKey])
-                inverted[featureKey] = [];
-            inverted[featureKey].push(featureName);
-        }
-    }
-    return inverted;
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-export function fromUniqueKeysCollectorCs(uniqueKeys) {
-    var payload = [];
-    var featuresPerKey = invertUniqueKeys(uniqueKeys);
-    var keys = Object.keys(featuresPerKey);
-    for (var k = 0; k < keys.length; k++) {
-        var key = keys[k];
-        var uniqueKeysPayload = {
-            k: key,
-            fs: featuresPerKey[key]
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export function fromUniqueKeysCollectorSs(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: featureKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
+var DATA_NAME = 'uniqueKeys';
 /**
  * Submitter that periodically posts impression counts
  */
@@ -59,6 +8,15 @@ export function uniqueKeysSubmitterFactory(params) {
     var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
-    return submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys');
+    // register unique keys submitter to be executed when uniqueKeys cache is full
+    uniqueKeys.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }

package/esm/trackers/strategy/strategyNone.js

@@ -13,7 +13,7 @@ export function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
                 // Increments impression counter per featureName
                 impressionsCounter.track(impression.feature, now, 1);
                 // Keep track by unique key
-                uniqueKeysTracker.track(impression.feature, impression.keyName);
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
             });
             return {
                 impressionsToStore: [],

package/esm/trackers/uniqueKeysTracker.js

@@ -1,11 +1,9 @@
 import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
-import { _Set } from '../utils/lang/sets';
 var noopFilterAdapter = {
     add: function () { return true; },
     contains: function () { return true; },
     clear: function () { }
 };
-var DEFAULT_CACHE_SIZE = 30000;
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
@@ -13,53 +11,17 @@ var DEFAULT_CACHE_SIZE = 30000;
  *
  * @param log Logger instance
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
+ * @param uniqueKeysCache cache to save unique keys
  */
-export function uniqueKeysTrackerFactory(log, filterAdapter, cacheSize) {
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
-    if (cacheSize === void 0) { cacheSize = DEFAULT_CACHE_SIZE; }
-    var uniqueKeysTracker = {};
-    var uniqueTrackerSize = 0;
     return {
-        track: function (featureName, key) {
-            if (!filterAdapter.add(featureName, key)) {
+        track: function (key, featureName) {
+            if (!filterAdapter.add(key, featureName)) {
                 log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
                 return;
             }
-            if (!uniqueKeysTracker[featureName])
-                uniqueKeysTracker[featureName] = new _Set();
-            var tracker = uniqueKeysTracker[featureName];
-            if (!tracker.has(key)) {
-                tracker.add(key);
-                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "Key " + key + " added to feature " + featureName);
-                uniqueTrackerSize++;
-            }
-            if (uniqueTrackerSize >= cacheSize) {
-                log.warn(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The UniqueKeysTracker size reached the maximum limit");
-                // @TODO trigger event to submitter to send mtk
-                uniqueTrackerSize = 0;
-            }
-        },
-        /**
-         * Pop the collected data, used as payload for posting.
-         */
-        pop: function () {
-            var data = uniqueKeysTracker;
-            uniqueKeysTracker = {};
-            return data;
-        },
-        /**
-         * Clear the data stored on the cache.
-         */
-        clear: function () {
-            uniqueKeysTracker = {};
-        },
-        /**
-         * Check if the cache is empty.
-         */
-        isEmpty: function () {
-            return Object.keys(uniqueKeysTracker).length === 0;
+            uniqueKeysCache.track(key, featureName);
         }
     };
 }

package/esm/utils/constants/index.js

@@ -38,6 +38,7 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
+export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.1",
+  "version": "1.6.2-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/sdkFactory/index.ts

@@ -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.
@@ -44,6 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storageFactoryParams: IStorageFactoryParams = {
     impressionsQueueSize: settings.scheduler.impressionsQueueSize,
     eventsQueueSize: settings.scheduler.eventsQueueSize,
+    uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
     optimize: shouldBeOptimized(settings),
 
     // ATM, only used by InLocalStorage
@@ -52,6 +52,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.
@@ -70,9 +71,9 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
 
   const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, filterAdapterFactory && filterAdapterFactory()) : undefined;
+  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
   const strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts!) :
-    (impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!) : strategyDebugFactory(observer);
+    (storageFactoryParams.impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!) : strategyDebugFactory(observer);
 
   const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);

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,7 +125,7 @@ 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));
     },
 

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 { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -45,6 +46,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(params.eventsQueueSize),
       telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? 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/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 { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { 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
+    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : 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, LOCALHOST_MODE, 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,11 @@ 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,
+    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : undefined,
+    
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -29,6 +32,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/uniqueKeysCacheInMemory.ts

@@ -0,0 +1,83 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet, setToArray, _Set } from '../../utils/lang/sets';
+import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+
+const DEFAULT_CACHE_SIZE = 30000;
+
+export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  private onFullQueue?: () => void;
+  private readonly maxStorage: number;
+  private uniqueTrackerSize = 0;
+  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+
+  constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = uniqueKeysQueueSize;
+    this.uniqueKeysTracker = {};
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
+
+  /**
+   * Store unique keys in sequential order
+   * key: string = feature name.
+   * value: Set<string> = set of unique keys. 
+   */
+  track(key: string, featureName: string) {
+    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
+    const tracker = this.uniqueKeysTracker[featureName];
+    if (!tracker.has(key)) {
+      tracker.add(key);
+      this.uniqueTrackerSize++;
+    }
+    if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+      this.uniqueTrackerSize = 0;
+      this.onFullQueue();
+    }
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.uniqueKeysTracker = {};
+  }
+
+  /**
+   * Pop the collected data, used as payload for posting.
+   */
+  pop() {
+    const data = this.uniqueKeysTracker;
+    this.uniqueKeysTracker = {};
+    return this.fromUniqueKeysCollector(data);
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return Object.keys(this.uniqueKeysTracker).length === 0;
+  }
+  
+  /**
+   * Converts `uniqueKeys` data from cache into request payload for SS.
+   */
+  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+    const payload = [];
+    const featureNames = Object.keys(uniqueKeys);
+    for (let i = 0; i < featureNames.length; i++) {
+      const featureName = featureNames[i];
+      const featureKeys = setToArray(uniqueKeys[featureName]);
+      const uniqueKeysPayload = {
+        f: featureName,
+        ks: featureKeys
+      };
+
+      payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+  }
+  
+}

package/src/storages/inMemory/uniqueKeysCacheInMemoryCS.ts

@@ -0,0 +1,89 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet, setToArray, _Set } from '../../utils/lang/sets';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+
+const DEFAULT_CACHE_SIZE = 30000;
+
+export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+
+  private onFullQueue?: () => void;
+  private readonly maxStorage: number;
+  private uniqueTrackerSize = 0;
+  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+
+  /**
+   *
+   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+   */
+  constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {   
+    this.maxStorage = uniqueKeysQueueSize;
+    this.uniqueKeysTracker = {};
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
+
+  /**
+   * Store unique keys in sequential order
+   * key: string = key.
+   * value: HashSet<string> = set of split names. 
+   */
+  track(key: string, featureName: string) {
+    
+    if (!this.uniqueKeysTracker[key]) this.uniqueKeysTracker[key] = new _Set();
+    const tracker = this.uniqueKeysTracker[key];
+    if (!tracker.has(featureName)) {
+      tracker.add(featureName);
+      this.uniqueTrackerSize++;
+    }
+    if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+      this.uniqueTrackerSize = 0;
+      this.onFullQueue();
+    }
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.uniqueKeysTracker = {};
+  }
+
+  /**
+   * Pop the collected data, used as payload for posting.
+   */
+  pop() {
+    const data = this.uniqueKeysTracker;
+    this.uniqueKeysTracker = {};
+    return this.fromUniqueKeysCollector(data);
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return Object.keys(this.uniqueKeysTracker).length === 0;
+  }
+  
+  /**
+   * Converts `uniqueKeys` data from cache into request payload.
+   */
+  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+    const payload = [];
+    const featureKeys = Object.keys(uniqueKeys);
+    for (let k = 0; k < featureKeys.length; k++) {
+      const featureKey = featureKeys[k];
+      const featureNames = setToArray(uniqueKeys[featureKey]);
+      const uniqueKeysPayload = {
+        k: featureKey,
+        fs: featureNames
+      };
+
+      payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+  }
+  
+}