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

package/cjs/trackers/uniqueKeysTracker.js

@@ -13,11 +13,15 @@ var noopFilterAdapter = {
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
- * @param filterAdapter filter adapter
  * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
  */
 function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -25,6 +29,9 @@ function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
                 return;
             }
             uniqueKeysCache.track(key, featureName);
+        },
+        stop: function () {
+            clearInterval(intervalId);
         }
     };
 }

package/esm/evaluator/index.js

@@ -32,44 +32,43 @@ export function evaluateFeature(log, key, splitName, attributes, storage) {
     return getEvaluation(log, stringifiedSplit, key, attributes, storage);
 }
 export 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 (thenable(stringifiedSplits)) ?
-        stringifiedSplits.then(function (splits) { return getEvaluations(log, splitNames, splits, key, attributes, storage); })
+    return 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);
 }
-function getEvaluation(log, stringifiedSplit, key, attributes, storage) {
+function getEvaluation(log, splitJSON, key, attributes, storage) {
     var evaluation = {
         treatment: CONTROL,
         label: LabelsConstants.SPLIT_NOT_FOUND,
         config: null
     };
-    if (stringifiedSplit) {
-        var splitJSON_1 = JSON.parse(stringifiedSplit);
-        var split_1 = Engine.parse(log, splitJSON_1, storage);
+    if (splitJSON) {
+        var split_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 (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/esm/integrations/ga/GaToSplit.js

@@ -13,7 +13,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 () {
@@ -21,10 +21,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 = {
@@ -157,7 +160,7 @@ export function fixEventTypeId(log, eventTypeId) {
  * @param {object} log factory logger
  */
 export 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: defaultPrefix,
         // We set default identities if key and TT are present in settings.core
@@ -243,5 +246,5 @@ export 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);
 }

package/esm/sdkClient/sdkClient.js

@@ -6,7 +6,7 @@ import { clientInputValidationDecorator } from './clientInputValidation';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export 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 objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -28,6 +28,8 @@ export function sdkClientFactory(params, isSharedClient) {
                 // Release the API Key if it is the main client
                 if (!isSharedClient)
                     releaseApiKey(settings.core.authorizationKey);
+                if (uniqueKeysTracker)
+                    uniqueKeysTracker.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/esm/sdkFactory/index.js

@@ -52,7 +52,8 @@ 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 });
+    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;
@@ -68,7 +69,6 @@ export function sdkFactory(params) {
     }
     var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-    var telemetryTracker = 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/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/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.
@@ -31,15 +32,12 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     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.
@@ -44,15 +45,12 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      */
     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/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

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/inRedis/ImpressionCountsCacheInRedis.js

@@ -3,11 +3,13 @@ import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCache
 import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
 var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
     __extends(ImpressionCountsCacheInRedis, _super);
-    function ImpressionCountsCacheInRedis(log, key, redis, impressionCountsCacheSize) {
+    function ImpressionCountsCacheInRedis(log, key, redis, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
         var _this = _super.call(this, impressionCountsCacheSize) || this;
         _this.log = log;
         _this.key = key;
         _this.redis = redis;
+        _this.refreshRate = refreshRate;
         _this.onFullQueue = function () { _this.postImpressionCountsInRedis(); };
         return _this;
     }
@@ -15,6 +17,8 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         var counts = this.pop();
         var keys = Object.keys(counts);
+        if (!keys)
+            return Promise.resolve(false);
         var pipeline = this.redis.pipeline();
         keys.forEach(function (key) {
             pipeline.hincrby(_this.key, key, counts[key]);
@@ -28,15 +32,15 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         })
             .catch(function (err) {
             _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
-            return false;
+            return Promise.resolve(false);
         });
     };
-    ImpressionCountsCacheInRedis.prototype.start = function (refreshRate) {
-        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
-        this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+    ImpressionCountsCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
     };
     ImpressionCountsCacheInRedis.prototype.stop = function () {
-        clearInterval(this.handle);
+        clearInterval(this.intervalId);
+        return this.postImpressionCountsInRedis();
     };
     return ImpressionCountsCacheInRedis;
 }(ImpressionCountsCacheInMemory));

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -59,17 +59,17 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing errors
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, newStringifiedSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                newStringifiedSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.redis.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.redis.set(splitKey, newStringifiedSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -96,8 +96,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.redis.del(_this.keys.buildSplitKey(name));
         });
@@ -120,7 +119,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             this.log.error(LOG_PREFIX + this.redisError);
             return Promise.reject(this.redisError);
         }
-        return this.redis.get(this.keys.buildSplitKey(name));
+        return this.redis.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Set till number.
@@ -155,7 +155,12 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      */
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); }).then(processPipelineAnswer);
+        return this.redis.keys(this.keys.searchPatternForSplitKeys())
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(processPipelineAnswer)
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.
@@ -215,7 +220,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
         return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         })

package/esm/storages/inRedis/index.js

@@ -44,11 +44,12 @@ export function InRedisStorage(options) {
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                redisClient.disconnect();
+                var promises = [];
                 if (impressionCountsCache)
-                    impressionCountsCache.stop();
+                    promises.push(impressionCountsCache.stop());
                 if (uniqueKeysCache)
-                    uniqueKeysCache.stop();
+                    promises.push(uniqueKeysCache.stop());
+                return Promise.all(promises).then(function () { redisClient.disconnect(); });
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/esm/storages/inRedis/uniqueKeysCacheInRedis.js

@@ -5,19 +5,23 @@ import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
     __extends(UniqueKeysCacheInRedis, _super);
-    function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize) {
+    function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
         var _this = _super.call(this, uniqueKeysQueueSize) || this;
         _this.log = log;
         _this.key = key;
         _this.redis = redis;
+        _this.refreshRate = refreshRate;
         _this.onFullQueue = function () { _this.postUniqueKeysInRedis(); };
         return _this;
     }
     UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
         var _this = this;
-        var pipeline = this.redis.pipeline();
         var featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames)
+            return Promise.resolve(false);
+        var pipeline = this.redis.pipeline();
         for (var i = 0; i < featureNames.length; i++) {
             var featureName = featureNames[i];
             var featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
@@ -37,15 +41,15 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         })
             .catch(function (err) {
             _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
-            return false;
+            return Promise.resolve(false);
         });
     };
-    UniqueKeysCacheInRedis.prototype.start = function (refreshRate) {
-        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
-        this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+    UniqueKeysCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
     };
     UniqueKeysCacheInRedis.prototype.stop = function () {
-        clearInterval(this.handle);
+        clearInterval(this.intervalId);
+        return this.postUniqueKeysInRedis();
     };
     return UniqueKeysCacheInRedis;
 }(UniqueKeysCacheInMemory));

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -46,17 +46,17 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                stringifiedNewSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.wrapper.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.wrapper.set(splitKey, stringifiedNewSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type and segment count of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -80,8 +80,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
@@ -101,7 +100,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * or rejected if wrapper operation fails.
      */
     SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name));
+        return this.wrapper.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Get list of splits.
@@ -114,7 +114,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getMany(keys).then(function (splitDefinitions) {
             var splits = {};
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         });
@@ -126,7 +127,11 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      */
     SplitsCachePluggable.prototype.getAll = function () {
         var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return Promise.all(listOfKeys.map(_this.wrapper.get)); });
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -24,8 +24,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
             log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             forOwn(splitsMock, function (val, name) {
                 splits.push([
-                    name,
-                    JSON.stringify({
+                    name, {
                         name: name,
                         status: 'ACTIVE',
                         killed: false,
@@ -34,7 +33,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                         conditions: val.conditions || [],
                         configurations: val.configurations,
                         trafficTypeName: val.trafficTypeName
-                    })
+                    }
                 ]);
             });
             return Promise.all([

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -37,7 +37,7 @@ export function computeSplitsMutation(entries) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE') {
-            accum.added.push([split.name, JSON.stringify(split)]);
+            accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });

package/esm/trackers/strategy/strategyOptimized.js

@@ -14,7 +14,8 @@ export function strategyOptimizedFactory(impressionsObserver, impressionsCounter
                 impression.pt = impressionsObserver.testAndSet(impression);
                 var now = Date.now();
                 // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
+                if (impression.pt)
+                    impressionsCounter.track(impression.feature, now, 1);
                 // Checks if the impression should be added in queue to be sent
                 if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
                     impressionsToStore.push(impression);

package/esm/trackers/telemetryTracker.js

@@ -46,6 +46,11 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -56,6 +61,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }