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

package/cjs/consent/sdkUserConsent.js

@@ -39,8 +39,8 @@ function createUserConsentAPI(params) {
                     if (events.clear)
                         events.clear(); // @ts-ignore
                     if (impressions.clear)
-                        impressions.clear();
-                    if (impressionCounts)
+                        impressions.clear(); // @ts-ignore
+                    if (impressionCounts && impressionCounts.clear)
                         impressionCounts.clear();
                 }
             }

package/cjs/sdkFactory/index.js

@@ -58,8 +58,17 @@ function sdkFactory(params) {
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     var observer = impressionsObserverFactory();
     var uniqueKeysTracker = storageFactoryParams.impressionsMode === constants_3.NONE ? (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
-    var strategy = (storageFactoryParams.optimize) ? (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts) :
-        (storageFactoryParams.impressionsMode === constants_3.NONE) ? (0, strategyNone_1.strategyNoneFactory)(storage.impressionCounts, uniqueKeysTracker) : (0, strategyDebug_1.strategyDebugFactory)(observer);
+    var strategy;
+    switch (storageFactoryParams.impressionsMode) {
+        case constants_3.OPTIMIZED:
+            strategy = (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts);
+            break;
+        case constants_3.NONE:
+            strategy = (0, strategyNone_1.strategyNoneFactory)(storage.impressionCounts, uniqueKeysTracker);
+            break;
+        default:
+            strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
+    }
     var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
     var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);

package/cjs/storages/KeyBuilderSS.js

@@ -23,6 +23,12 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
+    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
+        return this.prefix + ".impressions.count";
+    };
+    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
+        return this.prefix + ".uniquekeys";
+    };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };

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

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemory = void 0;
 var sets_1 = require("../../utils/lang/sets");
-var DEFAULT_CACHE_SIZE = 30000;
+var constants_1 = require("../inRedis/constants");
 var UniqueKeysCacheInMemory = /** @class */ (function () {
     function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
         this.uniqueTrackerSize = 0;
         this.maxStorage = uniqueKeysQueueSize;
         this.uniqueKeysTracker = {};

package/cjs/storages/inMemory/uniqueKeysCacheInMemoryCS.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemoryCS = void 0;
 var sets_1 = require("../../utils/lang/sets");
-var DEFAULT_CACHE_SIZE = 30000;
+var constants_1 = require("../inRedis/constants");
 var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
     /**
      *
@@ -10,7 +10,7 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
      * 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; }
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
         this.uniqueTrackerSize = 0;
         this.maxStorage = uniqueKeysQueueSize;
         this.uniqueKeysTracker = {};

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,46 @@
+"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) {
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.onFullQueue = function () { _this.postImpressionCountsInRedis(); };
+        return _this;
+    }
+    ImpressionCountsCacheInRedis.prototype.postImpressionCountsInRedis = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        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 (refreshRate) {
+        if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
+        this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+    };
+    ImpressionCountsCacheInRedis.prototype.stop = function () {
+        clearInterval(this.handle);
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
+exports.ImpressionCountsCacheInRedis = ImpressionCountsCacheInRedis;

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,8 @@ 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");
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -18,13 +20,19 @@ 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;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode;
         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 +40,18 @@ 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();
+                if (impressionCountsCache)
+                    impressionCountsCache.stop();
+                if (uniqueKeysCache)
+                    uniqueKeysCache.stop();
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/cjs/storages/inRedis/uniqueKeysCacheInRedis.js

@@ -0,0 +1,55 @@
+"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) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.onFullQueue = function () { _this.postUniqueKeysInRedis(); };
+        return _this;
+    }
+    UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
+        var _this = this;
+        var pipeline = this.redis.pipeline();
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        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 (refreshRate) {
+        if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
+        this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+    };
+    UniqueKeysCacheInRedis.prototype.stop = function () {
+        clearInterval(this.handle);
+    };
+    return UniqueKeysCacheInRedis;
+}(uniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
+exports.UniqueKeysCacheInRedis = UniqueKeysCacheInRedis;

package/cjs/trackers/impressionsTracker.js

@@ -23,21 +23,23 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
             var impressionsCount = impressions.length;
             var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
             var impressionsToListenerCount = impressionsToListener.length;
-            var res = impressionsCache.track(impressionsToStore);
-            // If we're on an async storage, handle error and log it.
-            if ((0, thenable_1.thenable)(res)) {
-                res.then(function () {
-                    log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                }).catch(function (err) {
-                    log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                });
-            }
-            else {
-                // Record when impressionsCache is sync only (standalone mode)
-                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                if (telemetryCache) {
-                    telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
+            if (impressionsToStore.length > 0) {
+                var res = impressionsCache.track(impressionsToStore);
+                // If we're on an async storage, handle error and log it.
+                if ((0, thenable_1.thenable)(res)) {
+                    res.then(function () {
+                        log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                    }).catch(function (err) {
+                        log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                    });
+                }
+                else {
+                    // Record when impressionsCache is sync only (standalone mode)
+                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                    if (telemetryCache) {
+                        telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
+                    }
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor

package/esm/consent/sdkUserConsent.js

@@ -36,8 +36,8 @@ export function createUserConsentAPI(params) {
                     if (events.clear)
                         events.clear(); // @ts-ignore
                     if (impressions.clear)
-                        impressions.clear();
-                    if (impressionCounts)
+                        impressions.clear(); // @ts-ignore
+                    if (impressionCounts && impressionCounts.clear)
                         impressionCounts.clear();
                 }
             }

package/esm/sdkFactory/index.js

@@ -14,7 +14,7 @@ import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE } from '../utils/constants';
+import { NONE, OPTIMIZED } from '../utils/constants';
 /**
  * Modular SDK factory
  */
@@ -55,8 +55,17 @@ export function sdkFactory(params) {
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     var observer = impressionsObserverFactory();
     var uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
-    var strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts) :
-        (storageFactoryParams.impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker) : strategyDebugFactory(observer);
+    var strategy;
+    switch (storageFactoryParams.impressionsMode) {
+        case OPTIMIZED:
+            strategy = strategyOptimizedFactory(observer, storage.impressionCounts);
+            break;
+        case NONE:
+            strategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
+            break;
+        default:
+            strategy = strategyDebugFactory(observer);
+    }
     var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);

package/esm/storages/KeyBuilderSS.js

@@ -20,6 +20,12 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
+    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
+        return this.prefix + ".impressions.count";
+    };
+    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
+        return this.prefix + ".uniquekeys";
+    };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -1,7 +1,11 @@
 import { truncateTimeFrame } from '../../utils/time';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory() {
+    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
+        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = 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.
@@ -16,6 +20,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/esm/storages/inMemory/uniqueKeysCacheInMemory.js

@@ -1,5 +1,5 @@
 import { setToArray, _Set } from '../../utils/lang/sets';
-var DEFAULT_CACHE_SIZE = 30000;
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var UniqueKeysCacheInMemory = /** @class */ (function () {
     function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }

package/esm/storages/inMemory/uniqueKeysCacheInMemoryCS.js

@@ -1,5 +1,5 @@
 import { setToArray, _Set } from '../../utils/lang/sets';
-var DEFAULT_CACHE_SIZE = 30000;
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
     /**
      *

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,43 @@
+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) {
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.onFullQueue = function () { _this.postImpressionCountsInRedis(); };
+        return _this;
+    }
+    ImpressionCountsCacheInRedis.prototype.postImpressionCountsInRedis = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        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 (refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+    };
+    ImpressionCountsCacheInRedis.prototype.stop = function () {
+        clearInterval(this.handle);
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory));
+export { ImpressionCountsCacheInRedis };

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,18 @@ 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();
+                if (impressionCountsCache)
+                    impressionCountsCache.stop();
+                if (uniqueKeysCache)
+                    uniqueKeysCache.stop();
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/esm/storages/inRedis/uniqueKeysCacheInRedis.js

@@ -0,0 +1,52 @@
+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) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.onFullQueue = function () { _this.postUniqueKeysInRedis(); };
+        return _this;
+    }
+    UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
+        var _this = this;
+        var pipeline = this.redis.pipeline();
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        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 (refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+    };
+    UniqueKeysCacheInRedis.prototype.stop = function () {
+        clearInterval(this.handle);
+    };
+    return UniqueKeysCacheInRedis;
+}(UniqueKeysCacheInMemory));
+export { UniqueKeysCacheInRedis };

package/esm/trackers/impressionsTracker.js

@@ -20,21 +20,23 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
             var impressionsCount = impressions.length;
             var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
             var impressionsToListenerCount = impressionsToListener.length;
-            var res = impressionsCache.track(impressionsToStore);
-            // If we're on an async storage, handle error and log it.
-            if (thenable(res)) {
-                res.then(function () {
-                    log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                }).catch(function (err) {
-                    log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                });
-            }
-            else {
-                // Record when impressionsCache is sync only (standalone mode)
-                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                if (telemetryCache) {
-                    telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(DEDUPED, deduped);
+            if (impressionsToStore.length > 0) {
+                var res = impressionsCache.track(impressionsToStore);
+                // If we're on an async storage, handle error and log it.
+                if (thenable(res)) {
+                    res.then(function () {
+                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                    }).catch(function (err) {
+                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                    });
+                }
+                else {
+                    // Record when impressionsCache is sync only (standalone mode)
+                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                    if (telemetryCache) {
+                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(DEDUPED, deduped);
+                    }
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.2",
+  "version": "1.6.2-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

package/src/sdkFactory/index.ts

@@ -17,7 +17,7 @@ import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE } from '../utils/constants';
+import { NONE, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -72,8 +72,18 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const observer = impressionsObserverFactory();
   const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
-  const strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts!) :
-    (storageFactoryParams.impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!) : strategyDebugFactory(observer);
+
+  let strategy;
+  switch (storageFactoryParams.impressionsMode) {
+    case OPTIMIZED: 
+      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
+      break;
+    case NONE: 
+      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
+      break;
+    default: 
+      strategy = strategyDebugFactory(observer);
+  }
 
   const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);

package/src/storages/KeyBuilderSS.ts

@@ -27,6 +27,14 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.impressions`;
   }
 
+  buildImpressionsCountKey() {
+    return `${this.prefix}.impressions.count`;
+  }
+  
+  buildUniqueKeysKey() {
+    return `${this.prefix}.uniquekeys`;
+  }
+
   buildEventsKey() {
     return `${this.prefix}.events`;
   }

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,8 +1,16 @@
 import { truncateTimeFrame } from '../../utils/time';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 import { IImpressionCountsCacheSync } from '../types';
 
 export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-  private cache: Record<string, number> = {};
+  protected cache: Record<string, number> = {};
+  private readonly maxStorage: number;
+  protected onFullQueue?: () => void;
+  private cacheSize = 0;
+  
+  constructor(impressionCountsCacheSize: number = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = impressionCountsCacheSize;
+  }
 
   /**
   * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -18,6 +26,13 @@ export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync
     const key = this._makeKey(featureName, timeFrame);
     const 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;
+      }
+    }
   }
 
 

package/src/storages/inMemory/uniqueKeysCacheInMemory.ts

@@ -1,15 +1,14 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
-
-const DEFAULT_CACHE_SIZE = 30000;
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
 export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
-  private onFullQueue?: () => void;
+  protected onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+  protected uniqueKeysTracker: { [keys: string]: ISet<string> };
 
   constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;

package/src/storages/inMemory/uniqueKeysCacheInMemoryCS.ts

@@ -1,8 +1,7 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
-
-const DEFAULT_CACHE_SIZE = 30000;
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
 export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
 

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -0,0 +1,48 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+
+export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private handle: any;
+  
+  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number) {
+    super(impressionCountsCacheSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
+  }
+  
+  postImpressionCountsInRedis(){
+    const counts = this.pop();
+    const keys = Object.keys(counts);
+    const pipeline = this.redis.pipeline();
+    keys.forEach(key => {
+      pipeline.hincrby(this.key, key, counts[key]);
+    });
+    return pipeline.exec()
+      .then(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(err => {
+        this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
+        return false;
+      });
+  }
+  
+  start(refreshRate: number = REFRESH_RATE) {
+    this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+  }
+  
+  stop() {
+    clearInterval(this.handle);
+  }
+}

package/src/storages/inRedis/constants.ts

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

package/src/storages/inRedis/index.ts

@@ -6,8 +6,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';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -22,15 +24,18 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
-
+  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: IStorageFactoryParams): IStorageAsync {
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
+    const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
+    const 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', () => {
       onReadyCb();
+      if (impressionCountsCache) impressionCountsCache.start();
+      if (uniqueKeysCache) uniqueKeysCache.start();
 
       // Synchronize config
       telemetry.recordConfig();
@@ -40,13 +45,17 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       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,
+      uniqueKeys: uniqueKeysCache,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
       destroy() {
         redisClient.disconnect();
+        if (impressionCountsCache) impressionCountsCache.stop();
+        if (uniqueKeysCache) uniqueKeysCache.stop();
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };

package/src/storages/inRedis/uniqueKeysCacheInRedis.ts

@@ -0,0 +1,61 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+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';
+import { ILogger } from '../../logger/types';
+
+export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private handle: any;
+  
+  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
+    super(uniqueKeysQueueSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.onFullQueue = () => {this.postUniqueKeysInRedis();};
+  }
+  
+  postUniqueKeysInRedis() {
+    const pipeline = this.redis.pipeline();
+    
+    const featureNames = Object.keys(this.uniqueKeysTracker);
+    for (let i = 0; i < featureNames.length; i++) {
+      const featureName = featureNames[i];
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const uniqueKeysPayload = {
+        f: featureName,
+        ks: featureKeys
+      };
+
+      pipeline.rpush(this.key, JSON.stringify(uniqueKeysPayload));
+    }
+    this.clear();
+    return pipeline.exec()
+      .then(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(err => {
+        this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
+        return false;
+      });
+  }
+  
+    
+  start(refreshRate: number = REFRESH_RATE) {
+    this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+  }
+  
+  stop() {
+    clearInterval(this.handle);
+  }
+  
+}

package/src/storages/types.ts

@@ -347,7 +347,7 @@ export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProdu
  * Only in memory. Named `ImpressionsCounter` in spec.
  */
 export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  // Used by impressions tracker
+// Used by impressions tracker
   track(featureName: string, timeFrame: number, amount: number): void
 
   // Used by impressions count submitter in standalone and producer mode
@@ -455,6 +455,7 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheSync,
   TEventsCache extends IEventsCacheBase,
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase
@@ -462,7 +463,7 @@ export interface IStorageBase<
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: IImpressionCountsCacheSync,
+  impressionCounts?: TImpressionsCountCache,
   events: TEventsCache,
   telemetry?: TTelemetryCache,
   uniqueKeys?: TUniqueKeysCache,
@@ -474,6 +475,7 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheBase
@@ -483,6 +485,7 @@ export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
   ITelemetryCacheAsync,
   IUniqueKeysCacheBase

package/src/trackers/impressionsTracker.ts

@@ -34,21 +34,23 @@ export function impressionsTrackerFactory(
       
       const impressionsToListenerCount = impressionsToListener.length;
       
-      const res = impressionsCache.track(impressionsToStore);
+      if ( impressionsToStore.length>0 ){
+        const res = impressionsCache.track(impressionsToStore);
 
-      // If we're on an async storage, handle error and log it.
-      if (thenable(res)) {
-        res.then(() => {
-          log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-        }).catch(err => {
-          log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-        });
-      } else {
-        // Record when impressionsCache is sync only (standalone mode)
-        // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-        if (telemetryCache) {
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
+        // If we're on an async storage, handle error and log it.
+        if (thenable(res)) {
+          res.then(() => {
+            log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+          }).catch(err => {
+            log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+          });
+        } else {
+          // Record when impressionsCache is sync only (standalone mode)
+          // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+          if (telemetryCache) {
+            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
+            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
+          }
         }
       }
 

package/types/storages/KeyBuilderSS.d.ts

@@ -6,6 +6,8 @@ export declare class KeyBuilderSS extends KeyBuilder {
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;
+    buildImpressionsCountKey(): string;
+    buildUniqueKeysKey(): string;
     buildEventsKey(): string;
     searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;

package/types/storages/inMemory/ImpressionCountsCacheInMemory.d.ts

@@ -1,6 +1,10 @@
 import { IImpressionCountsCacheSync } from '../types';
 export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-    private cache;
+    protected cache: Record<string, number>;
+    private readonly maxStorage;
+    protected onFullQueue?: () => void;
+    private cacheSize;
+    constructor(impressionCountsCacheSize?: number);
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */

package/types/storages/inMemory/uniqueKeysCacheInMemory.d.ts

@@ -1,10 +1,13 @@
 import { IUniqueKeysCacheBase } from '../types';
+import { ISet } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
-    private onFullQueue?;
+    protected onFullQueue?: () => void;
     private readonly maxStorage;
     private uniqueTrackerSize;
-    private uniqueKeysTracker;
+    protected uniqueKeysTracker: {
+        [keys: string]: ISet<string>;
+    };
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;
     /**

package/types/storages/inRedis/ImpressionCountsCacheInRedis.d.ts

@@ -0,0 +1,13 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private handle;
+    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number);
+    postImpressionCountsInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(refreshRate?: number): void;
+    stop(): void;
+}

package/types/storages/inRedis/constants.d.ts

@@ -1 +1,4 @@
 export declare const LOG_PREFIX = "storage:redis: ";
+export declare const DEFAULT_CACHE_SIZE = 30000;
+export declare const REFRESH_RATE = 300000;
+export declare const TTL_REFRESH = 3600;

package/types/storages/inRedis/uniqueKeysCacheInRedis.d.ts

@@ -0,0 +1,14 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/uniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private handle;
+    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number);
+    postUniqueKeysInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(refreshRate?: number): void;
+    stop(): void;
+}

package/types/storages/types.d.ts

@@ -373,20 +373,20 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
-    impressionCounts?: IImpressionCountsCacheSync;
+    impressionCounts?: TImpressionsCountCache;
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;

package/types/sync/submitters/impressionCountsSubmitterInRedis.d.ts

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function impressionCountsSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

package/types/sync/submitters/uniqueKeysSubmitterInRedis.d.ts

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function uniqueKeysSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;