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

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/TelemetryCacheInRedis.js

@@ -1,6 +1,10 @@
+import { parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
+import { isNaNNumber, isString } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -28,6 +32,102 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, 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 _Map();
+            Object.keys(latencies).forEach(function (field) {
+                var parsedField = parseLatencyField(field);
+                if (isString(parsedField)) {
+                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(latencies[field]);
+                if (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 >= MAX_LATENCY_BUCKET_COUNT) {
+                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    return;
+                }
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: newBuckets(),
+                        ts: newBuckets(),
+                        tc: newBuckets(),
+                        tcs: newBuckets(),
+                        tr: 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 _Map();
+            Object.keys(exceptions).forEach(function (field) {
+                var parsedField = parseExceptionField(field);
+                if (isString(parsedField)) {
+                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(exceptions[field]);
+                if (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 _Map();
+            Object.keys(configs).forEach(function (field) {
+                var parsedField = parseMetadata(field);
+                if (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;
 }());
 export { TelemetryCacheInRedis };

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -0,0 +1,68 @@
+import { __extends } from "tslib";
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+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, 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 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 = 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, TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(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();
+    };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCacheInRedis.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return this.redis.lrange(this.key, 0, count - 1).then(function (uniqueKeyItems) {
+            return _this.redis.ltrim(_this.key, uniqueKeyItems.length, -1)
+                .then(function () { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+        });
+    };
+    return UniqueKeysCacheInRedis;
+}(UniqueKeysCacheInMemory));
+export { UniqueKeysCacheInRedis };

package/esm/storages/inRedis/constants.js

@@ -1 +1,4 @@
 export var LOG_PREFIX = 'storage:redis: ';
+export var DEFAULT_CACHE_SIZE = 30000;
+export var REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
+export var TTL_REFRESH = 3600; // 1hr

package/esm/storages/inRedis/index.js

@@ -5,8 +5,10 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { STORAGE_REDIS } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
+import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
+import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -15,13 +17,19 @@ export function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = validatePrefix(options.prefix);
     function InRedisStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode;
         var keys = new KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
+        var impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
+        var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
+            if (impressionCountsCache)
+                impressionCountsCache.start();
+            if (uniqueKeysCache)
+                uniqueKeysCache.start();
             // Synchronize config
             telemetry.recordConfig();
         });
@@ -29,12 +37,19 @@ export function InRedisStorage(options) {
             splits: new SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
+            impressionCounts: impressionCountsCache,
             events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
             telemetry: telemetry,
+            uniqueKeys: uniqueKeysCache,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                redisClient.disconnect();
+                var promises = [];
+                if (impressionCountsCache)
+                    promises.push(impressionCountsCache.stop());
+                if (uniqueKeysCache)
+                    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/pluggable/ImpressionCountsCachePluggable.js

@@ -0,0 +1,78 @@
+import { __extends } from "tslib";
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { REFRESH_RATE } from '../inRedis/constants';
+import { LOG_PREFIX } from './constants';
+var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
+    __extends(ImpressionCountsCachePluggable, _super);
+    function ImpressionCountsCachePluggable(log, key, wrapper, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeImpressionCounts(); };
+        return _this;
+    }
+    ImpressionCountsCachePluggable.prototype.storeImpressionCounts = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        if (!keys.length)
+            return Promise.resolve(false);
+        var pipeline = keys.reduce(function (pipeline, key) {
+            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+        }, Promise.resolve());
+        return pipeline.catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCachePluggable.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.storeImpressionCounts();
+    };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCachePluggable.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.key)
+            .then(function (keys) {
+            return keys.length ? Promise.all(keys.map(function (key) { return _this.wrapper.get(key); }))
+                .then(function (counts) {
+                keys.forEach(function (key) { return _this.wrapper.del(key).catch(function () { }); });
+                var impressionsCount = { pf: [] };
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    var count = counts[i];
+                    var keyFeatureNameAndTime = key.split('::');
+                    if (keyFeatureNameAndTime.length !== 3) {
+                        _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                        continue;
+                    }
+                    var timeFrame = parseInt(keyFeatureNameAndTime[2]);
+                    if (isNaN(timeFrame)) {
+                        _this.log.error(LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        continue;
+                    }
+                    // @ts-ignore
+                    var rawCount = parseInt(count);
+                    if (isNaN(rawCount)) {
+                        _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                        continue;
+                    }
+                    impressionsCount.pf.push({
+                        f: keyFeatureNameAndTime[1],
+                        m: timeFrame,
+                        rc: rawCount,
+                    });
+                }
+                return impressionsCount;
+            }) : undefined;
+        });
+    };
+    return ImpressionCountsCachePluggable;
+}(ImpressionCountsCacheInMemory));
+export { ImpressionCountsCachePluggable };

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/storages/pluggable/TelemetryCachePluggable.js

@@ -1,4 +1,10 @@
+import { parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { findLatencyIndex } from '../findLatencyIndex';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { isString, isNaNNumber } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 var TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.
@@ -19,6 +25,126 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.incr(this.keys.buildExceptionKey(method))
             .catch(function () { });
     };
+    TelemetryCachePluggable.prototype.recordConfig = function () {
+        var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_PLUGGABLE));
+        return this.wrapper.set(this.keys.buildInitKey(), value).catch(function () { });
+    };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popLatencies = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
+            return latencyKeys.length ?
+                _this.wrapper.getMany(latencyKeys).then(function (latencies) {
+                    var result = new _Map();
+                    for (var i = 0; i < latencyKeys.length; i++) {
+                        var field = latencyKeys[i].split('::')[1];
+                        var parsedField = parseLatencyField(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(latencies[i]);
+                        if (isNaNNumber(count)) {
+                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            continue;
+                        }
+                        var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                        if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
+                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            continue;
+                        }
+                        if (!result.has(metadata))
+                            result.set(metadata, {
+                                t: newBuckets(),
+                                ts: newBuckets(),
+                                tc: newBuckets(),
+                                tcs: newBuckets(),
+                                tr: newBuckets(),
+                            });
+                        result.get(metadata)[method][bucket] = count;
+                    }
+                    return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
+                }) :
+                // If latencyKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popExceptions = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
+            return exceptionKeys.length ?
+                _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
+                    var result = new _Map();
+                    for (var i = 0; i < exceptionKeys.length; i++) {
+                        var field = exceptionKeys[i].split('::')[1];
+                        var parsedField = parseExceptionField(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(exceptions[i]);
+                        if (isNaNNumber(count)) {
+                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            continue;
+                        }
+                        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 Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
+                }) :
+                // If exceptionKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popConfigs = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
+            return configKeys.length ?
+                _this.wrapper.getMany(configKeys).then(function (configs) {
+                    var result = new _Map();
+                    for (var i = 0; i < configKeys.length; i++) {
+                        var field = configKeys[i].split('::')[1];
+                        var parsedField = parseMetadata(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        var metadata = parsedField[0];
+                        try { // @ts-ignore
+                            var config = JSON.parse(configs[i]);
+                            result.set(metadata, config);
+                        }
+                        catch (e) {
+                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                        }
+                    }
+                    return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
+                }) :
+                // If configKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
     return TelemetryCachePluggable;
 }());
 export { TelemetryCachePluggable };

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -0,0 +1,58 @@
+import { __extends } from "tslib";
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
+import { LOG_PREFIX } from './constants';
+var UniqueKeysCachePluggable = /** @class */ (function (_super) {
+    __extends(UniqueKeysCachePluggable, _super);
+    function UniqueKeysCachePluggable(log, key, wrapper, 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.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeUniqueKeys(); };
+        return _this;
+    }
+    UniqueKeysCachePluggable.prototype.storeUniqueKeys = function () {
+        var _this = this;
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames.length)
+            return Promise.resolve(false);
+        var pipeline = featureNames.reduce(function (pipeline, featureName) {
+            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            return pipeline.then(function () { return _this.wrapper.pushItems(_this.key, [JSON.stringify(uniqueKeysPayload)]); });
+        }, Promise.resolve());
+        this.clear();
+        return pipeline.catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            return false;
+        });
+    };
+    UniqueKeysCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeUniqueKeys.bind(this), this.refreshRate);
+    };
+    UniqueKeysCachePluggable.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.storeUniqueKeys();
+    };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCachePluggable.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return Promise.resolve(count || this.wrapper.getItemsCount(this.key))
+            .then(function (count) { return _this.wrapper.popItems(_this.key, count); })
+            .then(function (uniqueKeyItems) { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+    };
+    return UniqueKeysCachePluggable;
+}(UniqueKeysCacheInMemory));
+export { UniqueKeysCachePluggable };