@splitsoftware/splitio-commons 1.6.2-rc.9 → 1.7.1

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -7,7 +7,9 @@ var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
 exports.MAX_LATENCY_BUCKET_COUNT = 23;
 function newBuckets() {
-    return new Array(exports.MAX_LATENCY_BUCKET_COUNT).fill(0);
+    // 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;
@@ -15,30 +17,56 @@ var ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-function shouldRecordTelemetry(params) {
-    return params.mode !== constants_1.LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
+function shouldRecordTelemetry(_a) {
+    var settings = _a.settings;
+    return settings.mode !== constants_1.LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory() {
+    function TelemetryCacheInMemory(splits, segments) {
+        this.splits = splits;
+        this.segments = segments;
+        // isEmpty flag
+        this.e = true;
         this.notReadyUsage = 0;
+        /** Usage stats */
         this.impressionStats = [0, 0, 0];
         this.eventStats = [0, 0];
-        // @ts-expect-error
         this.lastSync = {};
-        // @ts-expect-error
         this.httpErrors = {};
-        // @ts-expect-error
         this.httpLatencies = {};
         this.authRejections = 0;
         this.tokenRefreshes = 0;
         this.streamingEvents = [];
         this.tags = [];
-        // @ts-expect-error
         this.exceptions = {};
-        // @ts-expect-error
         this.latencies = {};
     }
+    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
+    TelemetryCacheInMemory.prototype.clear = function () { };
+    TelemetryCacheInMemory.prototype.pop = function () {
+        this.e = true;
+        return {
+            lS: this.getLastSynchronization(),
+            mL: this.popLatencies(),
+            mE: this.popExceptions(),
+            hE: this.popHttpErrors(),
+            hL: this.popHttpLatencies(),
+            tR: this.popTokenRefreshes(),
+            aR: this.popAuthRejections(),
+            iQ: this.getImpressionStats(constants_1.QUEUED),
+            iDe: this.getImpressionStats(constants_1.DEDUPED),
+            iDr: this.getImpressionStats(constants_1.DROPPED),
+            spC: this.splits && this.splits.getSplitNames().length,
+            seC: this.segments && this.segments.getRegisteredSegments().length,
+            skC: this.segments && this.segments.getKeysCount(),
+            sL: this.getSessionLength(),
+            eQ: this.getEventStats(constants_1.QUEUED),
+            eD: this.getEventStats(constants_1.DROPPED),
+            sE: this.popStreamingEvents(),
+            t: this.popTags(),
+        };
+    };
     TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
         return this.timeUntilReady;
     };
@@ -62,44 +90,41 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
         this.impressionStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getEventStats = function (type) {
         return this.eventStats[type];
     };
     TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
         this.eventStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
         return this.lastSync;
     };
     TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
         this.lastSync[resource] = timeMs;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpErrors = function () {
-        var result = this.httpErrors; // @ts-expect-error
+        var result = this.httpErrors;
         this.httpErrors = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
-        if (!this.httpErrors[resource])
-            this.httpErrors[resource] = {};
-        if (!this.httpErrors[resource][status]) {
-            this.httpErrors[resource][status] = 1;
-        }
-        else {
-            this.httpErrors[resource][status]++;
-        }
+        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
+        statusErrors[status] = (statusErrors[status] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
-        var result = this.httpLatencies; // @ts-expect-error
+        var result = this.httpLatencies;
         this.httpLatencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
-        if (!this.httpLatencies[resource]) {
-            this.httpLatencies[resource] = newBuckets();
-        }
-        this.httpLatencies[resource][(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
+        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popAuthRejections = function () {
         var result = this.authRejections;
@@ -108,6 +133,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
         this.authRejections++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
         var result = this.tokenRefreshes;
@@ -116,6 +142,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
         this.tokenRefreshes++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
         return this.streamingEvents.splice(0);
@@ -124,6 +151,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
             this.streamingEvents.push(streamingEvent);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTags = function () {
         return this.tags.splice(0);
@@ -132,36 +160,33 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.tags.length < MAX_TAGS) {
             this.tags.push(tag);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getSessionLength = function () {
         return this.sessionLength;
     };
     TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
         this.sessionLength = ms;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popExceptions = function () {
-        var result = this.exceptions; // @ts-expect-error
+        var result = this.exceptions;
         this.exceptions = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordException = function (method) {
-        if (!this.exceptions[method]) {
-            this.exceptions[method] = 1;
-        }
-        else {
-            this.exceptions[method]++;
-        }
+        this.exceptions[method] = (this.exceptions[method] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popLatencies = function () {
-        var result = this.latencies; // @ts-expect-error
+        var result = this.latencies;
         this.latencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
-        if (!this.latencies[method]) {
-            this.latencies[method] = newBuckets();
-        }
-        this.latencies[method][(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
+        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        this.e = false;
     };
     return TelemetryCacheInMemory;
 }());

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueKeysCacheInMemory = exports.fromUniqueKeysCollector = void 0;
+var sets_1 = require("../../utils/lang/sets");
+var constants_1 = require("../inRedis/constants");
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+function fromUniqueKeysCollector(uniqueKeys) {
+    var payload = [];
+    var featureNames = Object.keys(uniqueKeys);
+    for (var i = 0; i < featureNames.length; i++) {
+        var featureName = featureNames[i];
+        var userKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
+        var uniqueKeysPayload = {
+            f: featureName,
+            ks: userKeys
+        };
+        payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+}
+exports.fromUniqueKeysCollector = fromUniqueKeysCollector;
+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 per feature.
+     */
+    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
+        if (!this.uniqueKeysTracker[featureName])
+            this.uniqueKeysTracker[featureName] = new sets_1._Set();
+        var tracker = this.uniqueKeysTracker[featureName];
+        if (!tracker.has(userKey)) {
+            tracker.add(userKey);
+            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 fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    return UniqueKeysCacheInMemory;
+}());
+exports.UniqueKeysCacheInMemory = UniqueKeysCacheInMemory;

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,76 @@
+"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 per feature.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {
+        if (!this.uniqueKeysTracker[userKey])
+            this.uniqueKeysTracker[userKey] = new sets_1._Set();
+        var tracker = this.uniqueKeysTracker[userKey];
+        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 userKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < userKeys.length; k++) {
+            var userKey = userKeys[k];
+            var featureNames = (0, sets_1.setToArray)(uniqueKeys[userKey]);
+            var uniqueKeysPayload = {
+                k: userKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+exports.UniqueKeysCacheInMemoryCS = UniqueKeysCacheInMemoryCS;

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpressionCountsCacheInRedis = void 0;
+var tslib_1 = require("tslib");
+var lang_1 = require("../../utils/lang");
+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();
+    };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCacheInRedis.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.redis.hgetall(this.key)
+            .then(function (counts) {
+            if (!Object.keys(counts).length)
+                return undefined;
+            _this.redis.del(_this.key).catch(function () { });
+            var pf = [];
+            (0, lang_1.forOwn)(counts, function (count, key) {
+                var nameAndTime = key.split('::');
+                if (nameAndTime.length !== 2) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error spliting key " + key);
+                    return;
+                }
+                var timeFrame = parseInt(nameAndTime[1]);
+                if (isNaN(timeFrame)) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error parsing time frame " + nameAndTime[1]);
+                    return;
+                }
+                var rawCount = parseInt(count);
+                if (isNaN(rawCount)) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error parsing raw count " + count);
+                    return;
+                }
+                pf.push({
+                    f: nameAndTime[0],
+                    m: timeFrame,
+                    rc: rawCount,
+                });
+            });
+            return { pf: pf };
+        });
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
+exports.ImpressionCountsCacheInRedis = ImpressionCountsCacheInRedis;

package/cjs/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionsCacheInRedis = void 0;
+var utils_1 = require("../utils");
 var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 var ImpressionsCacheInRedis = /** @class */ (function () {
     function ImpressionsCacheInRedis(log, key, redis, metadata) {
@@ -11,31 +12,13 @@ var ImpressionsCacheInRedis = /** @class */ (function () {
     }
     ImpressionsCacheInRedis.prototype.track = function (impressions) {
         var _this = this;
-        return this.redis.rpush(this.key, this._toJSON(impressions)).then(function (queuedCount) {
+        return this.redis.rpush(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata)).then(function (queuedCount) {
             // If this is the creation of the key on Redis, set the expiration for it in 1hr.
             if (queuedCount === impressions.length) {
                 return _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH);
             }
         });
     };
-    ImpressionsCacheInRedis.prototype._toJSON = function (impressions) {
-        var _this = this;
-        return impressions.map(function (impression) {
-            var keyName = impression.keyName, bucketingKey = impression.bucketingKey, feature = impression.feature, treatment = impression.treatment, label = impression.label, time = impression.time, changeNumber = impression.changeNumber;
-            return JSON.stringify({
-                m: _this.metadata,
-                i: {
-                    k: keyName,
-                    b: bucketingKey,
-                    f: feature,
-                    t: treatment,
-                    r: label,
-                    c: changeNumber,
-                    m: time
-                }
-            });
-        });
-    };
     ImpressionsCacheInRedis.prototype.count = function () {
         return this.redis.llen(this.key).catch(function () { return 0; });
     };

package/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,13 +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 utils_1 = require("../utils");
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -44,7 +44,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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);
+                var parsedField = (0, utils_1.parseLatencyField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
                     return;
@@ -81,7 +81,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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);
+                var parsedField = (0, utils_1.parseExceptionField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
                     return;
@@ -114,7 +114,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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);
+                var parsedField = (0, utils_1.parseMetadata)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
                     return;

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -0,0 +1,71 @@
+"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();
+    };
+    /**
+     * 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_1.UniqueKeysCacheInMemory));
+exports.UniqueKeysCacheInRedis = UniqueKeysCacheInRedis;

package/cjs/storages/inRedis/constants.js

@@ -1,4 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_PREFIX = void 0;
+exports.TTL_REFRESH = exports.REFRESH_RATE = exports.DEFAULT_CACHE_SIZE = exports.LOG_PREFIX = void 0;
 exports.LOG_PREFIX = 'storage:redis: ';
+exports.DEFAULT_CACHE_SIZE = 30000;
+exports.REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
+exports.TTL_REFRESH = 3600; // 1hr

package/cjs/storages/inRedis/index.js

@@ -10,6 +10,9 @@ var ImpressionsCacheInRedis_1 = require("./ImpressionsCacheInRedis");
 var EventsCacheInRedis_1 = require("./EventsCacheInRedis");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
+var UniqueKeysCacheInRedis_1 = require("./UniqueKeysCacheInRedis");
+var ImpressionCountsCacheInRedis_1 = require("./ImpressionCountsCacheInRedis");
+var utils_1 = require("../utils");
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -17,14 +20,21 @@ var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
 function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
-    function InRedisStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
+    function InRedisStorageFactory(params) {
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
+        var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter_1.RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
+        var impressionCountsCache = impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInRedis_1.ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
+        var uniqueKeysCache = impressionsMode === constants_1.NONE ? new UniqueKeysCacheInRedis_1.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();
         });
@@ -32,12 +42,19 @@ function InRedisStorage(options) {
             splits: new SplitsCacheInRedis_1.SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis_1.SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis_1.ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
+            impressionCounts: impressionCountsCache,
             events: new EventsCacheInRedis_1.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
             }
         };