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

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();
         }
     };
 }

package/cjs/storages/inMemory/InMemoryStorageCS.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 UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
@@ -18,16 +19,19 @@ function InMemoryStorageCSFactory(params) {
         splits: new SplitsCacheInMemory_1.SplitsCacheInMemory(),
         segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
         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 && (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)() ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
+        uniqueKeys: params.impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemoryCS_1.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/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -25,9 +25,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]--;
@@ -38,19 +37,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 ((0, AbstractSplitsCacheSync_1.usesSegments)(parsedSplit))
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount++;
             return true;
         }
@@ -63,15 +61,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 ((0, AbstractSplitsCacheSync_1.usesSegments)(parsedSplit))
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount--;
             return true;
         }

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,19 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = void 0;
+exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = exports.newBuckets = exports.MAX_LATENCY_BUCKET_COUNT = void 0;
+var constants_1 = require("../../utils/constants");
 var findLatencyIndex_1 = require("../findLatencyIndex");
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
+exports.MAX_LATENCY_BUCKET_COUNT = 23;
 function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+    // 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];
 }
+exports.newBuckets = newBuckets;
 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.
  */
-function shouldRecordTelemetry() {
-    return Math.random() <= ACCEPTANCE_RANGE;
+function shouldRecordTelemetry(params) {
+    return params.mode !== constants_1.LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueKeysCacheInMemory = void 0;
+var sets_1 = require("../../utils/lang/sets");
+var constants_1 = require("../inRedis/constants");
+var UniqueKeysCacheInMemory = /** @class */ (function () {
+    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.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 sets_1._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 = (0, sets_1.setToArray)(uniqueKeys[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemory;
+}());
+exports.UniqueKeysCacheInMemory = UniqueKeysCacheInMemory;

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

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

package/cjs/storages/inRedis/EventsCacheInRedis.js

@@ -42,7 +42,7 @@ var EventsCacheInRedis = /** @class */ (function () {
     };
     /**
      * Pop the given number of events from the storage.
-     * The returned promise rejects if the wrapper operation fails.
+     * The returned promise rejects if the redis operation fails.
      *
      * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
      * It is the submitter responsability to handle that.

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpressionCountsCacheInRedis = void 0;
+var tslib_1 = require("tslib");
+var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCacheInMemory");
+var constants_1 = require("./constants");
+var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ImpressionCountsCacheInRedis, _super);
+    function ImpressionCountsCacheInRedis(log, key, redis, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = constants_1.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;
+    }
+    ImpressionCountsCacheInRedis.prototype.postImpressionCountsInRedis = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        if (!keys.length)
+            return Promise.resolve(false);
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        return pipeline.exec()
+            .then(function (data) {
+            // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+            if (data.length && data.length === keys.length) {
+                return _this.redis.expire(_this.key, constants_1.TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(constants_1.LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCacheInRedis.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.postImpressionCountsInRedis();
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
+exports.ImpressionCountsCacheInRedis = ImpressionCountsCacheInRedis;

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -62,17 +62,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)
             ]);
@@ -99,8 +99,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));
         });
@@ -123,7 +122,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             this.log.error(constants_1.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.
@@ -158,7 +158,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.
@@ -218,7 +223,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/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCacheInRedis = void 0;
+var KeyBuilderSS_1 = require("../KeyBuilderSS");
 var findLatencyIndex_1 = require("../findLatencyIndex");
 var telemetrySubmitter_1 = require("../../sync/submitters/telemetrySubmitter");
 var constants_1 = require("../../utils/constants");
+var lang_1 = require("../../utils/lang");
+var maps_1 = require("../../utils/lang/maps");
+var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -31,6 +35,102 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         var value = JSON.stringify((0, telemetrySubmitter_1.getTelemetryConfigStats)(constants_1.CONSUMER_MODE, constants_1.STORAGE_REDIS));
         return this.redis.hset(key, field, value).catch(function () { });
     };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popLatencies = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
+            var result = new maps_1._Map();
+            Object.keys(latencies).forEach(function (field) {
+                var parsedField = (0, KeyBuilderSS_1.parseLatencyField)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(latencies[field]);
+                if ((0, lang_1.isNaNNumber)(count)) {
+                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                if (bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT) {
+                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    return;
+                }
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        ts: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tc: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tcs: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tr: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                    });
+                result.get(metadata)[method][bucket] = count;
+            });
+            return _this.redis.del(_this.keys.latencyPrefix).then(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popExceptions = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
+            var result = new maps_1._Map();
+            Object.keys(exceptions).forEach(function (field) {
+                var parsedField = (0, KeyBuilderSS_1.parseExceptionField)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(exceptions[field]);
+                if ((0, lang_1.isNaNNumber)(count)) {
+                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1];
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: 0,
+                        ts: 0,
+                        tc: 0,
+                        tcs: 0,
+                        tr: 0,
+                    });
+                result.get(metadata)[method] = count;
+            });
+            return _this.redis.del(_this.keys.exceptionPrefix).then(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popConfigs = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
+            var result = new maps_1._Map();
+            Object.keys(configs).forEach(function (field) {
+                var parsedField = (0, KeyBuilderSS_1.parseMetadata)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    return;
+                }
+                var metadata = parsedField[0];
+                try {
+                    var config = JSON.parse(configs[field]);
+                    result.set(metadata, config);
+                }
+                catch (e) {
+                    _this.log.error("Ignoring invalid config: " + configs[field]);
+                }
+            });
+            return _this.redis.del(_this.keys.initPrefix).then(function () { return result; });
+        });
+    };
     return TelemetryCacheInRedis;
 }());
 exports.TelemetryCacheInRedis = TelemetryCacheInRedis;

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueKeysCacheInRedis = void 0;
+var tslib_1 = require("tslib");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
+var sets_1 = require("../../utils/lang/sets");
+var constants_1 = require("./constants");
+var constants_2 = require("./constants");
+var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(UniqueKeysCacheInRedis, _super);
+    function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = constants_1.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 featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames.length)
+            return Promise.resolve(false);
+        var pipeline = this.redis.pipeline();
+        for (var i = 0; i < featureNames.length; i++) {
+            var featureName = featureNames[i];
+            var featureKeys = (0, sets_1.setToArray)(this.uniqueKeysTracker[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            pipeline.rpush(this.key, JSON.stringify(uniqueKeysPayload));
+        }
+        this.clear();
+        return pipeline.exec()
+            .then(function (data) {
+            // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+            if (data.length && data.length === featureNames.length) {
+                return _this.redis.expire(_this.key, constants_1.TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(constants_2.LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            return false;
+        });
+    };
+    UniqueKeysCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
+    };
+    UniqueKeysCacheInRedis.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.postUniqueKeysInRedis();
+    };
+    return UniqueKeysCacheInRedis;
+}(UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
+exports.UniqueKeysCacheInRedis = UniqueKeysCacheInRedis;