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

package/CHANGES.txt

@@ -1,3 +1,7 @@
+1.7.0 (September XXX, 2022)
+- Updated SDK telemetry to support pluggable storage, partial consumer mode, and synchronizer.
+- Updated storage implementations to improve the performance of split evaluations (i.e., `getTreatment(s)` method calls) when using the default storage in memory.
+
 1.6.1 (July 22, 2022)
 - Updated GoogleAnalyticsToSplit integration to validate `autoRequire` config parameter and avoid some wrong warning logs when mapping GA hit fields to Split event properties.
 

package/cjs/consent/sdkUserConsent.js

@@ -39,8 +39,8 @@ function createUserConsentAPI(params) {
                     if (events.clear)
                         events.clear(); // @ts-ignore
                     if (impressions.clear)
-                        impressions.clear();
-                    if (impressionCounts)
+                        impressions.clear(); // @ts-ignore
+                    if (impressionCounts && impressionCounts.clear)
                         impressionCounts.clear();
                 }
             }

package/cjs/evaluator/index.js

@@ -19,63 +19,62 @@ function treatmentsException(splitNames) {
     return evaluations;
 }
 function evaluateFeature(log, key, splitName, attributes, storage) {
-    var stringifiedSplit;
+    var parsedSplit;
     try {
-        stringifiedSplit = storage.splits.getSplit(splitName);
+        parsedSplit = storage.splits.getSplit(splitName);
     }
     catch (e) {
         // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
         return treatmentException;
     }
-    if ((0, thenable_1.thenable)(stringifiedSplit)) {
-        return stringifiedSplit.then(function (result) { return getEvaluation(log, result, key, attributes, storage); }).catch(
+    if ((0, thenable_1.thenable)(parsedSplit)) {
+        return parsedSplit.then(function (split) { return getEvaluation(log, split, key, attributes, storage); }).catch(
         // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         function () { return treatmentException; });
     }
-    return getEvaluation(log, stringifiedSplit, key, attributes, storage);
+    return getEvaluation(log, parsedSplit, key, attributes, storage);
 }
 exports.evaluateFeature = evaluateFeature;
 function evaluateFeatures(log, key, splitNames, attributes, storage) {
-    var stringifiedSplits;
+    var parsedSplits;
     try {
-        stringifiedSplits = storage.splits.getSplits(splitNames);
+        parsedSplits = storage.splits.getSplits(splitNames);
     }
     catch (e) {
         // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
         return treatmentsException(splitNames);
     }
-    return ((0, thenable_1.thenable)(stringifiedSplits)) ?
-        stringifiedSplits.then(function (splits) { return getEvaluations(log, splitNames, splits, key, attributes, storage); })
+    return (0, thenable_1.thenable)(parsedSplits) ?
+        parsedSplits.then(function (splits) { return getEvaluations(log, splitNames, splits, key, attributes, storage); })
             .catch(function () {
             // Exception on async `getSplits` storage. For example, when the storage is redis or
             // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
             return treatmentsException(splitNames);
         }) :
-        getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+        getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 exports.evaluateFeatures = evaluateFeatures;
-function getEvaluation(log, stringifiedSplit, key, attributes, storage) {
+function getEvaluation(log, splitJSON, key, attributes, storage) {
     var evaluation = {
         treatment: constants_1.CONTROL,
         label: LabelsConstants.SPLIT_NOT_FOUND,
         config: null
     };
-    if (stringifiedSplit) {
-        var splitJSON_1 = JSON.parse(stringifiedSplit);
-        var split_1 = Engine_1.Engine.parse(log, splitJSON_1, storage);
+    if (splitJSON) {
+        var split_1 = Engine_1.Engine.parse(log, splitJSON, storage);
         evaluation = split_1.getTreatment(key, attributes, evaluateFeature);
         // If the storage is async and the evaluated split uses segment, evaluation is thenable
         if ((0, thenable_1.thenable)(evaluation)) {
             return evaluation.then(function (result) {
                 result.changeNumber = split_1.getChangeNumber();
-                result.config = splitJSON_1.configurations && splitJSON_1.configurations[result.treatment] || null;
+                result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
                 return result;
             });
         }
         else {
             evaluation.changeNumber = split_1.getChangeNumber(); // Always sync and optional
-            evaluation.config = splitJSON_1.configurations && splitJSON_1.configurations[evaluation.treatment] || null;
+            evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
         }
     }
     return evaluation;

package/cjs/integrations/ga/GaToSplit.js

@@ -16,7 +16,7 @@ var logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window, pluginName, pluginConstructor, log, autoRequire) {
+function providePlugin(window, pluginName, pluginConstructor, log, autoRequire, telemetryTracker) {
     // get reference to global command queue. Init it if not defined yet.
     var gaAlias = window.GoogleAnalyticsObject || 'ga';
     window[gaAlias] = window[gaAlias] || function () {
@@ -24,10 +24,13 @@ function providePlugin(window, pluginName, pluginConstructor, log, autoRequire)
     };
     // provides the plugin for use with analytics.js.
     window[gaAlias]('provide', pluginName, pluginConstructor);
-    if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-        // Expecting spy on ga.q push method but not found
+    var hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+    if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
         log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
     }
+    if (telemetryTracker && hasAutoRequire) {
+        telemetryTracker.addTag('integration:ga-autorequire');
+    }
 }
 // Default mapping: object used for building the default mapper from hits to Split events
 var defaultMapping = {
@@ -163,7 +166,7 @@ exports.fixEventTypeId = fixEventTypeId;
  * @param {object} log factory logger
  */
 function GaToSplit(sdkOptions, params) {
-    var storage = params.storage, _a = params.settings, coreSettings = _a.core, log = _a.log;
+    var storage = params.storage, _a = params.settings, coreSettings = _a.core, log = _a.log, telemetryTracker = params.telemetryTracker;
     var defaultOptions = {
         prefix: exports.defaultPrefix,
         // We set default identities if key and TT are present in settings.core
@@ -249,6 +252,6 @@ function GaToSplit(sdkOptions, params) {
         return SplitTracker;
     }());
     // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-    providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+    providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }
 exports.GaToSplit = GaToSplit;

package/cjs/sdkClient/client.js

@@ -9,6 +9,15 @@ var trafficTypeExistance_1 = require("../utils/inputValidation/trafficTypeExista
 var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
+var utils_1 = require("../trackers/impressionObserver/utils");
+var treatmentNotReady = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
+function treatmentsNotReady(splitNames) {
+    var evaluations = {};
+    splitNames.forEach(function (splitName) {
+        evaluations[splitName] = treatmentNotReady;
+    });
+    return evaluations;
+}
 /**
  * Creator of base client with getTreatments and track methods.
  */
@@ -25,7 +34,11 @@ function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatment;
         };
-        var evaluation = (0, evaluator_1.evaluateFeature)(log, key, splitName, attributes, storage);
+        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            (0, evaluator_1.evaluateFeature)(log, key, splitName, attributes, storage) :
+            (0, utils_1.isStorageSync)(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                treatmentNotReady :
+                Promise.resolve(treatmentNotReady); // Promisify if async
         return (0, thenable_1.thenable)(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
     function getTreatmentWithConfig(key, splitName, attributes) {
@@ -44,7 +57,11 @@ function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatments;
         };
-        var evaluations = (0, evaluator_1.evaluateFeatures)(log, key, splitNames, attributes, storage);
+        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            (0, evaluator_1.evaluateFeatures)(log, key, splitNames, attributes, storage) :
+            (0, utils_1.isStorageSync)(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                treatmentsNotReady(splitNames) :
+                Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
         return (0, thenable_1.thenable)(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfig(key, splitNames, attributes) {
@@ -52,13 +69,8 @@ function clientFactory(params) {
     }
     // Internal function
     function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName, queue) {
-        var isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
         var matchingKey = (0, key_1.getMatching)(key);
         var bucketingKey = (0, key_1.getBucketing)(key);
-        // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-        if (!isSdkReady) {
-            evaluation = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
-        }
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(constants_2.IMPRESSION, [splitName, matchingKey, treatment, label]);
         if ((0, splitExistance_1.validateSplitExistance)(log, readinessManager, splitName, label, invokingMethodName)) {

package/cjs/sdkClient/sdkClient.js

@@ -9,7 +9,7 @@ var clientInputValidation_1 = require("./clientInputValidation");
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker;
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
     return (0, objectAssign_1.objectAssign)(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -31,6 +31,8 @@ function sdkClientFactory(params, isSharedClient) {
                 // Release the API Key if it is the main client
                 if (!isSharedClient)
                     (0, apiKey_1.releaseApiKey)(settings.core.authorizationKey);
+                if (uniqueKeysTracker)
+                    uniqueKeysTracker.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/cjs/sdkFactory/index.js

@@ -24,7 +24,6 @@ var constants_3 = require("../utils/constants");
 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, filterAdapterFactory = params.filterAdapterFactory;
     var log = settings.log;
-    var 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.
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
@@ -41,6 +40,7 @@ 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) {
@@ -54,14 +54,23 @@ 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 });
+    var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
+    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = impressionsMode === constants_3.NONE ? (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, filterAdapterFactory && filterAdapterFactory()) : undefined;
-    var strategy = (storageFactoryParams.optimize) ? (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts) :
-        (impressionsMode === constants_3.NONE) ? (0, strategyNone_1.strategyNoneFactory)(storage.impressionCounts, uniqueKeysTracker) : (0, strategyDebug_1.strategyDebugFactory)(observer);
+    var uniqueKeysTracker = storageFactoryParams.impressionsMode === constants_3.NONE ? (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
+    var strategy;
+    switch (storageFactoryParams.impressionsMode) {
+        case constants_3.OPTIMIZED:
+            strategy = (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts);
+            break;
+        case constants_3.NONE:
+            strategy = (0, strategyNone_1.strategyNoneFactory)(storage.impressionCounts, uniqueKeysTracker);
+            break;
+        default:
+            strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
+    }
     var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
     var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
-    var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     // 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, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };

package/cjs/sdkManager/index.js

@@ -15,15 +15,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 {
@@ -35,9 +27,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/cjs/services/splitApi.js

@@ -97,7 +97,7 @@ function splitApiFactory(settings, platform, telemetryTracker) {
          * @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 + "/api/v1/keys/cs";
+            var url = urls.telemetry + "/v1/keys/cs";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
         },
         /**
@@ -107,16 +107,16 @@ function splitApiFactory(settings, platform, telemetryTracker) {
          * @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 + "/api/v1/keys/ss";
+            var url = urls.telemetry + "/v1/keys/ss";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
         },
-        postMetricsConfig: function (body) {
+        postMetricsConfig: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/config";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.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(constants_1.TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
         }
     };
 }

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSplitsCacheAsync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -27,22 +28,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 = (0, objectAssign_1.objectAssign)({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(name, newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usesSegments = exports.AbstractSplitsCacheSync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -42,20 +43,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 = (0, objectAssign_1.objectAssign)({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(name, newSplit);
         }
         return false;
     };

package/cjs/storages/KeyBuilderSS.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyBuilderSS = void 0;
+exports.parseLatencyField = exports.parseExceptionField = exports.parseMetadata = exports.KeyBuilderSS = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilder_1 = require("./KeyBuilder");
-var methodNames = {
+var TelemetryCacheInMemory_1 = require("./inMemory/TelemetryCacheInMemory");
+var METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -14,7 +15,10 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     (0, tslib_1.__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 () {
@@ -23,6 +27,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";
     };
@@ -31,17 +41,52 @@ 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_1.KeyBuilder));
 exports.KeyBuilderSS = 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;
+}, {});
+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 })];
+}
+exports.parseMetadata = parseMetadata;
+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];
+}
+exports.parseExceptionField = parseExceptionField;
+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 >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT)
+        return "invalid bucket. Expected a number between 0 and " + (TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}
+exports.parseLatencyField = parseLatencyField;

package/cjs/storages/dataLoader.js

@@ -35,7 +35,7 @@ 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/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -96,9 +96,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) {
@@ -110,8 +109,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) {
@@ -120,7 +118,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
@@ -204,7 +203,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/cjs/storages/inLocalStorage/index.js

@@ -16,6 +16,7 @@ var InMemoryStorageCS_1 = require("../inMemory/InMemoryStorageCS");
 var constants_1 = require("./constants");
 var constants_2 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -37,13 +38,16 @@ function InLocalStorage(options) {
             impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(params.impressionsQueueSize),
             impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory_1.EventsCacheInMemory(params.eventsQueueSize),
-            telemetry: params.mode !== constants_2.LOCALHOST_MODE && (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)() ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+            telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+            uniqueKeys: params.impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
+                var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory_1.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/cjs/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionCountsCacheInMemory = void 0;
 var time_1 = require("../../utils/time");
+var constants_1 = require("../inRedis/constants");
 var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory() {
+    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
+        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = constants_1.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.
@@ -19,6 +23,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/cjs/storages/inMemory/InMemoryStorage.js

@@ -8,6 +8,7 @@ var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
+var UniqueKeysCacheInMemory_1 = require("./UniqueKeysCacheInMemory");
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -18,16 +19,19 @@ function InMemoryStorageFactory(params) {
         splits: new SplitsCacheInMemory_1.SplitsCacheInMemory(),
         segments: new SegmentsCacheInMemory_1.SegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+        impressionCounts: params.impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory_1.EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: params.mode !== constants_1.LOCALHOST_MODE ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+        uniqueKeys: params.impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemory_1.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();
         }
     };
 }