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

package/esm/sdkFactory/index.js

@@ -10,11 +10,16 @@ import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
+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, OPTIMIZED } from '../utils/constants';
 /**
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
     var log = settings.log;
     // @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.
@@ -32,6 +37,7 @@ export function sdkFactory(params) {
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // 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.
         onReadyCb: function (error) {
@@ -45,15 +51,26 @@ export function sdkFactory(params) {
     };
     var storage = storageFactory(storageFactoryParams);
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
-    // trackers
-    var observer = impressionsObserverFactory && impressionsObserverFactory();
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
+    var observer = impressionsObserverFactory();
+    var uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
+    var strategy;
+    switch (storageFactoryParams.impressionsMode) {
+        case OPTIMIZED:
+            strategy = strategyOptimizedFactory(observer, storage.impressionCounts);
+            break;
+        case NONE:
+            strategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
+            break;
+        default:
+            strategy = strategyDebugFactory(observer);
+    }
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);

package/esm/sdkManager/index.js

@@ -12,15 +12,7 @@ function collectTreatments(splitObject) {
     // Then extract the treatments from the partitions
     return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) { return v.treatment; }) : [];
 }
-function objectToView(json) {
-    var splitObject;
-    try {
-        // @ts-expect-error
-        splitObject = JSON.parse(json);
-    }
-    catch (e) {
-        return null;
-    }
+function objectToView(splitObject) {
     if (!splitObject)
         return null;
     return {
@@ -32,9 +24,9 @@ function objectToView(json) {
         configs: splitObject.configurations || {}
     };
 }
-function objectsToViews(jsons) {
+function objectsToViews(splitObjects) {
     var views = [];
-    jsons.forEach(function (split) {
+    splitObjects.forEach(function (split) {
         var view = objectToView(split);
         if (view)
             views.push(view);

package/esm/services/splitApi.js

@@ -87,13 +87,33 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.events + "/testImpressions/count";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
-        postMetricsConfig: function (body) {
+        /**
+         * Post unique keys for client side.
+         *
+         * @param body  unique keys payload
+         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+         */
+        postUniqueKeysBulkCs: function (body, headers) {
+            var url = urls.telemetry + "/v1/keys/cs";
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
+        /**
+         * Post unique keys for server side.
+         *
+         * @param body  unique keys payload
+         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+         */
+        postUniqueKeysBulkSs: function (body, headers) {
+            var url = urls.telemetry + "/v1/keys/ss";
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
+        postMetricsConfig: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/config";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         },
-        postMetricsUsage: function (body) {
+        postMetricsUsage: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/usage";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         }
     };
 }

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -24,22 +25,19 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
      * @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.
      */
     AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
-            if (split) {
-                var parsedSplit = JSON.parse(split);
-                if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                    parsedSplit.killed = true;
-                    parsedSplit.defaultTreatment = defaultTreatment;
-                    parsedSplit.changeNumber = changeNumber;
-                    var newSplit = JSON.stringify(parsedSplit);
-                    return _this.addSplit(name, newSplit);
-                }
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = objectAssign({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(name, newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -39,20 +40,17 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * @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.
      */
     AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var split = this.getSplit(name);
-        if (split) {
-            var parsedSplit = JSON.parse(split);
-            if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                parsedSplit.killed = true;
-                parsedSplit.defaultTreatment = defaultTreatment;
-                parsedSplit.changeNumber = changeNumber;
-                var newSplit = JSON.stringify(parsedSplit);
-                return this.addSplit(name, newSplit);
-            }
+        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+            var newSplit = objectAssign({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(name, newSplit);
         }
         return false;
     };

package/esm/storages/KeyBuilderSS.js

@@ -1,6 +1,7 @@
 import { __extends } from "tslib";
 import { KeyBuilder } from './KeyBuilder';
-var methodNames = {
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+var METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -11,7 +12,10 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     __extends(KeyBuilderSS, _super);
     function KeyBuilderSS(prefix, metadata) {
         var _this = _super.call(this, prefix) || this;
-        _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;
         return _this;
     }
     KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
@@ -20,6 +24,12 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
+    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
+        return this.prefix + ".impressions.count";
+    };
+    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
+        return this.prefix + ".uniquekeys";
+    };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };
@@ -28,17 +38,49 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     };
     /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
-        return this.prefix + ".telemetry.latencies::" + this.buildVersionablePrefix() + "/" + methodNames[method] + "/" + bucket;
+        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
+        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method];
     };
     KeyBuilderSS.prototype.buildInitKey = function () {
-        return this.prefix + ".telemetry.init::" + this.buildVersionablePrefix();
-    };
-    KeyBuilderSS.prototype.buildVersionablePrefix = function () {
-        return this.metadata.s + "/" + this.metadata.n + "/" + this.metadata.i;
+        return this.initPrefix + "::" + this.versionablePrefix;
     };
     return KeyBuilderSS;
 }(KeyBuilder));
 export { KeyBuilderSS };
+// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
+var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
+    acc[METHOD_NAMES[key]] = key;
+    return acc;
+}, {});
+export function parseMetadata(field) {
+    var parts = field.split('/');
+    if (parts.length !== 3)
+        return "invalid subsection count. Expected 3, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
+    return [JSON.stringify({ s: s, n: n, i: i })];
+}
+export function parseExceptionField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 4)
+        return "invalid subsection count. Expected 4, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    return [JSON.stringify({ s: s, n: n, i: i }), method];
+}
+export function parseLatencyField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 5)
+        return "invalid subsection count. Expected 5, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    var 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: s, n: n, i: i }), method, bucket];
+}

package/esm/storages/dataLoader.js

@@ -32,7 +32,7 @@ export function dataLoaderFactory(preloadedData) {
         storage.splits.clear();
         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(function (splitName) { return [splitName, splitsData[splitName]]; }));
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
         // add mySegments data
         var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -93,9 +93,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             this._decrementCounts(previousSplit);
-            localStorage.setItem(splitKey, split);
-            var parsedSplit = split ? JSON.parse(split) : null;
-            this._incrementCounts(parsedSplit);
+            localStorage.setItem(splitKey, JSON.stringify(split));
+            this._incrementCounts(split);
             return true;
         }
         catch (e) {
@@ -107,8 +106,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         try {
             var split = this.getSplit(name);
             localStorage.removeItem(this.keys.buildSplitKey(name));
-            var parsedSplit = JSON.parse(split);
-            this._decrementCounts(parsedSplit);
+            this._decrementCounts(split);
             return true;
         }
         catch (e) {
@@ -117,7 +115,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
-        return localStorage.getItem(this.keys.buildSplitKey(name));
+        var item = localStorage.getItem(this.keys.buildSplitKey(name));
+        return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when cache is ready but using a new split query, we must clear all split data
@@ -201,7 +200,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     /**
      * 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/esm/storages/inLocalStorage/index.js

@@ -11,8 +11,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';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -34,13 +35,16 @@ export function InLocalStorage(options) {
             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: function () {
+                var _a;
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
+                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -1,7 +1,11 @@
 import { truncateTimeFrame } from '../../utils/time';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory() {
+    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
+        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = DEFAULT_CACHE_SIZE; }
         this.cache = {};
+        this.cacheSize = 0;
+        this.maxStorage = impressionCountsCacheSize;
     }
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -16,6 +20,13 @@ var ImpressionCountsCacheInMemory = /** @class */ (function () {
         var key = this._makeKey(featureName, timeFrame);
         var 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;
+            }
+        }
     };
     /**
      * Pop the collected data, used as payload for posting.

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,8 +3,9 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 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
  *
@@ -15,16 +16,19 @@ export function InMemoryStorageFactory(params) {
         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,
+        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: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         }
     };
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,8 +3,9 @@ import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 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
  *
@@ -15,16 +16,19 @@ export function InMemoryStorageCSFactory(params) {
         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: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -22,9 +22,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
-        var splitFromMemory = this.getSplit(name);
-        if (splitFromMemory) { // We had this Split already
-            var previousSplit = JSON.parse(splitFromMemory);
+        var previousSplit = this.getSplit(name);
+        if (previousSplit) { // We had this Split already
             if (previousSplit.trafficTypeName) {
                 var previousTtName = previousSplit.trafficTypeName;
                 this.ttCache[previousTtName]--;
@@ -35,19 +34,18 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 this.splitsWithSegmentsCount--;
             }
         }
-        var parsedSplit = JSON.parse(split);
-        if (parsedSplit) {
+        if (split) {
             // Store the Split.
             this.splitsCache[name] = split;
             // Update TT cache
-            var ttName = parsedSplit.trafficTypeName;
+            var 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))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount++;
             return true;
         }
@@ -60,15 +58,14 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         if (split) {
             // Delete the Split
             delete this.splitsCache[name];
-            var parsedSplit = JSON.parse(split);
-            var ttName = parsedSplit.trafficTypeName;
+            var ttName = split.trafficTypeName;
             if (ttName) { // safeguard
                 this.ttCache[ttName]--; // Update tt cache
                 if (!this.ttCache[ttName])
                     delete this.ttCache[ttName];
             }
             // Update the segments count.
-            if (usesSegments(parsedSplit))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount--;
             return true;
         }

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,16 +1,20 @@
+import { LOCALHOST_MODE } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
-function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+export var MAX_LATENCY_BUCKET_COUNT = 23;
+export function newBuckets() {
+    // MAX_LATENCY_BUCKET_COUNT (length) is 23
+    // Not using Array.fill for old browsers compatibility
     return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 }
 var ACCEPTANCE_RANGE = 0.001;
 /**
- * Used on client-side. 0.1% of instances will track telemetry
+ * Record telemetry if mode is not localhost.
+ * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry() {
-    return Math.random() <= ACCEPTANCE_RANGE;
+export function shouldRecordTelemetry(params) {
+    return params.mode !== LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
     function TelemetryCacheInMemory() {

package/esm/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -0,0 +1,70 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+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 };