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

package/esm/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,75 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE } from '../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 = 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 _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 = setToArray(uniqueKeys[featureKey]);
+            var uniqueKeysPayload = {
+                k: featureKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+export { UniqueKeysCacheInMemoryCS };

package/esm/storages/inRedis/EventsCacheInRedis.js

@@ -39,7 +39,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/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,47 @@
+import { __extends } from "tslib";
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
+    __extends(ImpressionCountsCacheInRedis, _super);
+    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;
+    }
+    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, TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(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));
+export { ImpressionCountsCacheInRedis };

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,56 @@
+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();
+    };
+    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,40 @@
+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();
+    };
+    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.