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

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -1,8 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniqueKeysCacheInMemory = void 0;
+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; }
@@ -14,16 +32,14 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = feature name.
-     * value: Set<string> = set of unique keys.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+    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(key)) {
-            tracker.add(key);
+        if (!tracker.has(userKey)) {
+            tracker.add(userKey);
             this.uniqueTrackerSize++;
         }
         if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
@@ -43,7 +59,7 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.pop = function () {
         var data = this.uniqueKeysTracker;
         this.uniqueKeysTracker = {};
-        return this.fromUniqueKeysCollector(data);
+        return fromUniqueKeysCollector(data);
     };
     /**
      * Check if the cache is empty.
@@ -51,23 +67,6 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.isEmpty = function () {
         return Object.keys(this.uniqueKeysTracker).length === 0;
     };
-    /**
-     * Converts `uniqueKeys` data from cache into request payload for SS.
-     */
-    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
-        var payload = [];
-        var featureNames = Object.keys(uniqueKeys);
-        for (var i = 0; i < featureNames.length; i++) {
-            var featureName = featureNames[i];
-            var featureKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-            var uniqueKeysPayload = {
-                f: featureName,
-                ks: featureKeys
-            };
-            payload.push(uniqueKeysPayload);
-        }
-        return { keys: payload };
-    };
     return UniqueKeysCacheInMemory;
 }());
 exports.UniqueKeysCacheInMemory = UniqueKeysCacheInMemory;

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -19,14 +19,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = key.
-     * value: HashSet<string> = set of split names.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
-        if (!this.uniqueKeysTracker[key])
-            this.uniqueKeysTracker[key] = new sets_1._Set();
-        var tracker = this.uniqueKeysTracker[key];
+    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++;
@@ -61,12 +59,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
      */
     UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
         var payload = [];
-        var featureKeys = Object.keys(uniqueKeys);
-        for (var k = 0; k < featureKeys.length; k++) {
-            var featureKey = featureKeys[k];
-            var featureNames = (0, sets_1.setToArray)(uniqueKeys[featureKey]);
+        var 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: featureKey,
+                k: userKey,
                 fs: featureNames
             };
             payload.push(uniqueKeysPayload);

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -2,6 +2,7 @@
 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) {
@@ -45,6 +46,40 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         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 impressionsCount = { 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;
+                }
+                impressionsCount.pf.push({
+                    f: nameAndTime[0],
+                    m: timeFrame,
+                    rc: rawCount,
+                });
+            });
+            return impressionsCount;
+        });
+    };
     return ImpressionCountsCacheInRedis;
 }(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
 exports.ImpressionCountsCacheInRedis = ImpressionCountsCacheInRedis;

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -54,6 +54,18 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         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/pluggable/ImpressionCountsCachePluggable.js

@@ -38,6 +38,44 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.storeImpressionCounts();
     };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCachePluggable.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.key)
+            .then(function (keys) {
+            return keys.length ? Promise.all(keys.map(function (key) { return _this.wrapper.get(key); }))
+                .then(function (counts) {
+                keys.forEach(function (key) { return _this.wrapper.del(key).catch(function () { }); });
+                var impressionsCount = { pf: [] };
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    var count = counts[i];
+                    var keyFeatureNameAndTime = key.split('::');
+                    if (keyFeatureNameAndTime.length !== 3) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error spliting key " + key);
+                        continue;
+                    }
+                    var timeFrame = parseInt(keyFeatureNameAndTime[2]);
+                    if (isNaN(timeFrame)) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        continue;
+                    }
+                    // @ts-ignore
+                    var rawCount = parseInt(count);
+                    if (isNaN(rawCount)) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing raw count " + count);
+                        continue;
+                    }
+                    impressionsCount.pf.push({
+                        f: keyFeatureNameAndTime[1],
+                        m: timeFrame,
+                        rc: rawCount,
+                    });
+                }
+                return impressionsCount;
+            }) : undefined;
+        });
+    };
     return ImpressionCountsCachePluggable;
 }(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
 exports.ImpressionCountsCachePluggable = ImpressionCountsCachePluggable;

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -45,6 +45,17 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.storeUniqueKeys();
     };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCachePluggable.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return Promise.resolve(count || this.wrapper.getItemsCount(this.key))
+            .then(function (count) { return _this.wrapper.popItems(_this.key, count); })
+            .then(function (uniqueKeyItems) { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+    };
     return UniqueKeysCachePluggable;
 }(UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
 exports.UniqueKeysCachePluggable = UniqueKeysCachePluggable;

package/cjs/storages/pluggable/index.js

@@ -55,14 +55,19 @@ function PluggableStorage(options) {
         var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, impressionsMode = params.impressionsMode, matchingKey = params.matchingKey;
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
+        var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === constants_1.CONSUMER_PARTIAL_MODE;
-        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ?
-            isPartialConsumer ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
+        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) || isSyncronizer ?
+            isPartialConsumer ?
+                new TelemetryCacheInMemory_1.TelemetryCacheInMemory() :
+                new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
             undefined;
-        var impressionCountsCache = impressionsMode !== constants_1.DEBUG ?
-            isPartialConsumer ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : new ImpressionCountsCachePluggable_1.ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+        var impressionCountsCache = impressionsMode !== constants_1.DEBUG || isSyncronizer ?
+            isPartialConsumer ?
+                new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() :
+                new ImpressionCountsCachePluggable_1.ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
             undefined;
-        var uniqueKeysCache = impressionsMode === constants_1.NONE ?
+        var uniqueKeysCache = impressionsMode === constants_1.NONE || isSyncronizer ?
             isPartialConsumer ?
                 matchingKey === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
@@ -70,14 +75,15 @@ function PluggableStorage(options) {
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
             onReadyCb();
-            // Start periodic flush of async storages
-            if (impressionCountsCache && impressionCountsCache.start)
-                impressionCountsCache.start();
-            if (uniqueKeysCache && uniqueKeysCache.start)
-                uniqueKeysCache.start();
-            // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
-            if (telemetry && telemetry.recordConfig && mode)
-                telemetry.recordConfig();
+            // Start periodic flush of async storages if not running synchronizer (producer mode)
+            if (!isSyncronizer) {
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+            }
         }).catch(function (e) {
             e = e || new Error('Error connecting wrapper');
             onReadyCb(e);
@@ -91,9 +97,9 @@ function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            // Disconnect the underlying storage
+            // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
-                return Promise.all([
+                return Promise.all(isSyncronizer ? [] : [
                     impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
                     uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
                 ]).then(function () { return wrapper.disconnect(); });

package/esm/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -1,5 +1,22 @@
 import { setToArray, _Set } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export function fromUniqueKeysCollector(uniqueKeys) {
+    var payload = [];
+    var featureNames = Object.keys(uniqueKeys);
+    for (var i = 0; i < featureNames.length; i++) {
+        var featureName = featureNames[i];
+        var userKeys = setToArray(uniqueKeys[featureName]);
+        var uniqueKeysPayload = {
+            f: featureName,
+            ks: userKeys
+        };
+        payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+}
 var UniqueKeysCacheInMemory = /** @class */ (function () {
     function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
@@ -11,16 +28,14 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = feature name.
-     * value: Set<string> = set of unique keys.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
         if (!this.uniqueKeysTracker[featureName])
             this.uniqueKeysTracker[featureName] = new _Set();
         var tracker = this.uniqueKeysTracker[featureName];
-        if (!tracker.has(key)) {
-            tracker.add(key);
+        if (!tracker.has(userKey)) {
+            tracker.add(userKey);
             this.uniqueTrackerSize++;
         }
         if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
@@ -40,7 +55,7 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.pop = function () {
         var data = this.uniqueKeysTracker;
         this.uniqueKeysTracker = {};
-        return this.fromUniqueKeysCollector(data);
+        return fromUniqueKeysCollector(data);
     };
     /**
      * Check if the cache is empty.
@@ -48,23 +63,6 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.isEmpty = function () {
         return Object.keys(this.uniqueKeysTracker).length === 0;
     };
-    /**
-     * Converts `uniqueKeys` data from cache into request payload for SS.
-     */
-    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
-        var payload = [];
-        var featureNames = Object.keys(uniqueKeys);
-        for (var i = 0; i < featureNames.length; i++) {
-            var featureName = featureNames[i];
-            var featureKeys = setToArray(uniqueKeys[featureName]);
-            var uniqueKeysPayload = {
-                f: featureName,
-                ks: featureKeys
-            };
-            payload.push(uniqueKeysPayload);
-        }
-        return { keys: payload };
-    };
     return UniqueKeysCacheInMemory;
 }());
 export { UniqueKeysCacheInMemory };

package/esm/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -16,14 +16,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = key.
-     * value: HashSet<string> = set of split names.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
-        if (!this.uniqueKeysTracker[key])
-            this.uniqueKeysTracker[key] = new _Set();
-        var tracker = this.uniqueKeysTracker[key];
+    UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {
+        if (!this.uniqueKeysTracker[userKey])
+            this.uniqueKeysTracker[userKey] = new _Set();
+        var tracker = this.uniqueKeysTracker[userKey];
         if (!tracker.has(featureName)) {
             tracker.add(featureName);
             this.uniqueTrackerSize++;
@@ -58,12 +56,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
      */
     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 userKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < userKeys.length; k++) {
+            var userKey = userKeys[k];
+            var featureNames = setToArray(uniqueKeys[userKey]);
             var uniqueKeysPayload = {
-                k: featureKey,
+                k: userKey,
                 fs: featureNames
             };
             payload.push(uniqueKeysPayload);

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -1,4 +1,5 @@
 import { __extends } from "tslib";
+import { forOwn } from '../../utils/lang';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
 var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
@@ -42,6 +43,40 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         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 impressionsCount = { pf: [] };
+            forOwn(counts, function (count, key) {
+                var nameAndTime = key.split('::');
+                if (nameAndTime.length !== 2) {
+                    _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                    return;
+                }
+                var timeFrame = parseInt(nameAndTime[1]);
+                if (isNaN(timeFrame)) {
+                    _this.log.error(LOG_PREFIX + "Error parsing time frame " + nameAndTime[1]);
+                    return;
+                }
+                var rawCount = parseInt(count);
+                if (isNaN(rawCount)) {
+                    _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                    return;
+                }
+                impressionsCount.pf.push({
+                    f: nameAndTime[0],
+                    m: timeFrame,
+                    rc: rawCount,
+                });
+            });
+            return impressionsCount;
+        });
+    };
     return ImpressionCountsCacheInRedis;
 }(ImpressionCountsCacheInMemory));
 export { ImpressionCountsCacheInRedis };

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -51,6 +51,18 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.postUniqueKeysInRedis();
     };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCacheInRedis.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return this.redis.lrange(this.key, 0, count - 1).then(function (uniqueKeyItems) {
+            return _this.redis.ltrim(_this.key, uniqueKeyItems.length, -1)
+                .then(function () { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+        });
+    };
     return UniqueKeysCacheInRedis;
 }(UniqueKeysCacheInMemory));
 export { UniqueKeysCacheInRedis };

package/esm/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -35,6 +35,44 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.storeImpressionCounts();
     };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCachePluggable.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.key)
+            .then(function (keys) {
+            return keys.length ? Promise.all(keys.map(function (key) { return _this.wrapper.get(key); }))
+                .then(function (counts) {
+                keys.forEach(function (key) { return _this.wrapper.del(key).catch(function () { }); });
+                var impressionsCount = { pf: [] };
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    var count = counts[i];
+                    var keyFeatureNameAndTime = key.split('::');
+                    if (keyFeatureNameAndTime.length !== 3) {
+                        _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                        continue;
+                    }
+                    var timeFrame = parseInt(keyFeatureNameAndTime[2]);
+                    if (isNaN(timeFrame)) {
+                        _this.log.error(LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        continue;
+                    }
+                    // @ts-ignore
+                    var rawCount = parseInt(count);
+                    if (isNaN(rawCount)) {
+                        _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                        continue;
+                    }
+                    impressionsCount.pf.push({
+                        f: keyFeatureNameAndTime[1],
+                        m: timeFrame,
+                        rc: rawCount,
+                    });
+                }
+                return impressionsCount;
+            }) : undefined;
+        });
+    };
     return ImpressionCountsCachePluggable;
 }(ImpressionCountsCacheInMemory));
 export { ImpressionCountsCachePluggable };

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -42,6 +42,17 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.storeUniqueKeys();
     };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCachePluggable.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return Promise.resolve(count || this.wrapper.getItemsCount(this.key))
+            .then(function (count) { return _this.wrapper.popItems(_this.key, count); })
+            .then(function (uniqueKeyItems) { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+    };
     return UniqueKeysCachePluggable;
 }(UniqueKeysCacheInMemory));
 export { UniqueKeysCachePluggable };

package/esm/storages/pluggable/index.js

@@ -52,14 +52,19 @@ export function PluggableStorage(options) {
         var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, impressionsMode = params.impressionsMode, matchingKey = params.matchingKey;
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
+        var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
-        var telemetry = shouldRecordTelemetry(params) ?
-            isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper) :
+        var telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
+            isPartialConsumer ?
+                new TelemetryCacheInMemory() :
+                new TelemetryCachePluggable(log, keys, wrapper) :
             undefined;
-        var impressionCountsCache = impressionsMode !== DEBUG ?
-            isPartialConsumer ? new ImpressionCountsCacheInMemory() : new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+        var impressionCountsCache = impressionsMode !== DEBUG || isSyncronizer ?
+            isPartialConsumer ?
+                new ImpressionCountsCacheInMemory() :
+                new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
             undefined;
-        var uniqueKeysCache = impressionsMode === NONE ?
+        var uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
             isPartialConsumer ?
                 matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
@@ -67,14 +72,15 @@ export function PluggableStorage(options) {
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
             onReadyCb();
-            // Start periodic flush of async storages
-            if (impressionCountsCache && impressionCountsCache.start)
-                impressionCountsCache.start();
-            if (uniqueKeysCache && uniqueKeysCache.start)
-                uniqueKeysCache.start();
-            // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
-            if (telemetry && telemetry.recordConfig && mode)
-                telemetry.recordConfig();
+            // Start periodic flush of async storages if not running synchronizer (producer mode)
+            if (!isSyncronizer) {
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+            }
         }).catch(function (e) {
             e = e || new Error('Error connecting wrapper');
             onReadyCb(e);
@@ -88,9 +94,9 @@ export function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            // Disconnect the underlying storage
+            // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
-                return Promise.all([
+                return Promise.all(isSyncronizer ? [] : [
                     impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
                     uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
                 ]).then(function () { return wrapper.disconnect(); });

package/package.json

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

package/src/storages/inMemory/UniqueKeysCacheInMemory.ts

@@ -3,12 +3,31 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+  const payload = [];
+  const featureNames = Object.keys(uniqueKeys);
+  for (let i = 0; i < featureNames.length; i++) {
+    const featureName = featureNames[i];
+    const userKeys = setToArray(uniqueKeys[featureName]);
+    const uniqueKeysPayload = {
+      f: featureName,
+      ks: userKeys
+    };
+
+    payload.push(uniqueKeysPayload);
+  }
+  return { keys: payload };
+}
+
 export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
   protected onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  protected uniqueKeysTracker: { [keys: string]: ISet<string> };
+  protected uniqueKeysTracker: { [featureName: string]: ISet<string> };
 
   constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;
@@ -20,15 +39,13 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   }
 
   /**
-   * Store unique keys in sequential order
-   * key: string = feature name.
-   * value: Set<string> = set of unique keys.
+   * Store unique keys per feature.
    */
-  track(key: string, featureName: string) {
+  track(userKey: string, featureName: string) {
     if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
     const tracker = this.uniqueKeysTracker[featureName];
-    if (!tracker.has(key)) {
-      tracker.add(key);
+    if (!tracker.has(userKey)) {
+      tracker.add(userKey);
       this.uniqueTrackerSize++;
     }
     if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
@@ -50,7 +67,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   pop() {
     const data = this.uniqueKeysTracker;
     this.uniqueKeysTracker = {};
-    return this.fromUniqueKeysCollector(data);
+    return fromUniqueKeysCollector(data);
   }
 
   /**
@@ -60,23 +77,4 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     return Object.keys(this.uniqueKeysTracker).length === 0;
   }
 
-  /**
-   * Converts `uniqueKeys` data from cache into request payload for SS.
-   */
-  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
-    const payload = [];
-    const featureNames = Object.keys(uniqueKeys);
-    for (let i = 0; i < featureNames.length; i++) {
-      const featureName = featureNames[i];
-      const featureKeys = setToArray(uniqueKeys[featureName]);
-      const uniqueKeysPayload = {
-        f: featureName,
-        ks: featureKeys
-      };
-
-      payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-  }
-
 }

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -8,7 +8,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   private onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+  private uniqueKeysTracker: { [userKey: string]: ISet<string> };
 
   /**
    *
@@ -25,14 +25,12 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   }
 
   /**
-   * Store unique keys in sequential order
-   * key: string = key.
-   * value: HashSet<string> = set of split names.
+   * Store unique keys per feature.
    */
-  track(key: string, featureName: string) {
+  track(userKey: string, featureName: string) {
 
-    if (!this.uniqueKeysTracker[key]) this.uniqueKeysTracker[key] = new _Set();
-    const tracker = this.uniqueKeysTracker[key];
+    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new _Set();
+    const tracker = this.uniqueKeysTracker[userKey];
     if (!tracker.has(featureName)) {
       tracker.add(featureName);
       this.uniqueTrackerSize++;
@@ -69,14 +67,14 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   /**
    * Converts `uniqueKeys` data from cache into request payload.
    */
-  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: ISet<string> }): UniqueKeysPayloadCs {
     const payload = [];
-    const featureKeys = Object.keys(uniqueKeys);
-    for (let k = 0; k < featureKeys.length; k++) {
-      const featureKey = featureKeys[k];
-      const featureNames = setToArray(uniqueKeys[featureKey]);
+    const userKeys = Object.keys(uniqueKeys);
+    for (let k = 0; k < userKeys.length; k++) {
+      const userKey = userKeys[k];
+      const featureNames = setToArray(uniqueKeys[userKey]);
       const uniqueKeysPayload = {
-        k: featureKey,
+        k: userKey,
         fs: featureNames
       };
 

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -1,5 +1,7 @@
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { forOwn } from '../../utils/lang';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
 
@@ -20,7 +22,7 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
   }
 
-  private postImpressionCountsInRedis(){
+  private postImpressionCountsInRedis() {
     const counts = this.pop();
     const keys = Object.keys(counts);
     if (!keys.length) return Promise.resolve(false);
@@ -50,4 +52,44 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     clearInterval(this.intervalId);
     return this.postImpressionCountsInRedis();
   }
+
+  // Async consumer API, used by synchronizer
+  getImpressionsCount(): Promise<ImpressionCountsPayload | undefined> {
+    return this.redis.hgetall(this.key)
+      .then(counts => {
+        if (!Object.keys(counts).length) return undefined;
+
+        this.redis.del(this.key).catch(() => { /* no-op */ });
+
+        const impressionsCount: ImpressionCountsPayload = { pf: [] };
+
+        forOwn(counts, (count, key) => {
+          const nameAndTime = key.split('::');
+          if (nameAndTime.length !== 2) {
+            this.log.error(`${LOG_PREFIX}Error spliting key ${key}`);
+            return;
+          }
+
+          const timeFrame = parseInt(nameAndTime[1]);
+          if (isNaN(timeFrame)) {
+            this.log.error(`${LOG_PREFIX}Error parsing time frame ${nameAndTime[1]}`);
+            return;
+          }
+
+          const rawCount = parseInt(count);
+          if (isNaN(rawCount)) {
+            this.log.error(`${LOG_PREFIX}Error parsing raw count ${count}`);
+            return;
+          }
+
+          impressionsCount.pf.push({
+            f: nameAndTime[0],
+            m: timeFrame,
+            rc: rawCount,
+          });
+        });
+
+        return impressionsCount;
+      });
+  }
 }

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -5,6 +5,7 @@ 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';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
 
 export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
@@ -20,7 +21,7 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     this.key = key;
     this.redis = redis;
     this.refreshRate = refreshRate;
-    this.onFullQueue = () => {this.postUniqueKeysInRedis();};
+    this.onFullQueue = () => { this.postUniqueKeysInRedis(); };
   }
 
   private postUniqueKeysInRedis() {
@@ -62,4 +63,15 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     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.
+   */
+  popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
+    return this.redis.lrange(this.key, 0, count - 1).then(uniqueKeyItems => {
+      return this.redis.ltrim(this.key, uniqueKeyItems.length, -1)
+        .then(() => uniqueKeyItems.map(uniqueKeyItem => JSON.parse(uniqueKeyItem)));
+    });
+  }
+
 }

package/src/storages/inRedis/index.ts

@@ -52,7 +52,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
-      destroy(): Promise<void>{
+      destroy(): Promise<void> {
         let promises = [];
         if (impressionCountsCache) promises.push(impressionCountsCache.stop());
         if (uniqueKeysCache) promises.push(uniqueKeysCache.stop());

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -1,4 +1,5 @@
 import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { REFRESH_RATE } from '../inRedis/constants';
 import { IPluggableStorageWrapper } from '../types';
@@ -44,4 +45,48 @@ export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemor
     clearInterval(this.intervalId);
     return this.storeImpressionCounts();
   }
+
+  // Async consumer API, used by synchronizer
+  getImpressionsCount(): Promise<ImpressionCountsPayload | undefined> {
+    return this.wrapper.getKeysByPrefix(this.key)
+      .then(keys => {
+        return keys.length ? Promise.all(keys.map(key => this.wrapper.get(key)))
+          .then(counts => {
+            keys.forEach(key => this.wrapper.del(key).catch(() => { /* noop */ }));
+
+            const impressionsCount: ImpressionCountsPayload = { pf: [] };
+
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              const count = counts[i];
+
+              const keyFeatureNameAndTime = key.split('::');
+              if (keyFeatureNameAndTime.length !== 3) {
+                this.log.error(`${LOG_PREFIX}Error spliting key ${key}`);
+                continue;
+              }
+
+              const timeFrame = parseInt(keyFeatureNameAndTime[2]);
+              if (isNaN(timeFrame)) {
+                this.log.error(`${LOG_PREFIX}Error parsing time frame ${keyFeatureNameAndTime[2]}`);
+                continue;
+              }
+              // @ts-ignore
+              const rawCount = parseInt(count);
+              if (isNaN(rawCount)) {
+                this.log.error(`${LOG_PREFIX}Error parsing raw count ${count}`);
+                continue;
+              }
+
+              impressionsCount.pf.push({
+                f: keyFeatureNameAndTime[1],
+                m: timeFrame,
+                rc: rawCount,
+              });
+            }
+
+            return impressionsCount;
+          }) : undefined;
+      });
+  }
 }

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -4,6 +4,7 @@ import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
 
 export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
@@ -53,4 +54,14 @@ export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements
     return this.storeUniqueKeys();
   }
 
+  /**
+   * Async consumer API, used by synchronizer.
+   * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+   */
+  popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
+    return Promise.resolve(count || this.wrapper.getItemsCount(this.key))
+      .then(count => this.wrapper.popItems(this.key, count))
+      .then((uniqueKeyItems) => uniqueKeyItems.map(uniqueKeyItem => JSON.parse(uniqueKeyItem)));
+  }
+
 }

package/src/storages/pluggable/index.ts

@@ -64,14 +64,23 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     const { log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, impressionsMode, matchingKey } = params;
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
+
+    const isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
-    const telemetry = shouldRecordTelemetry(params) ?
-      isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper) :
+
+    const telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
+      isPartialConsumer ?
+        new TelemetryCacheInMemory() :
+        new TelemetryCachePluggable(log, keys, wrapper) :
       undefined;
-    const impressionCountsCache = impressionsMode !== DEBUG ?
-      isPartialConsumer ? new ImpressionCountsCacheInMemory() : new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+
+    const impressionCountsCache = impressionsMode !== DEBUG || isSyncronizer ?
+      isPartialConsumer ?
+        new ImpressionCountsCacheInMemory() :
+        new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
       undefined;
-    const uniqueKeysCache = impressionsMode === NONE ?
+
+    const uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
       isPartialConsumer ?
         matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
@@ -81,12 +90,12 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     const connectPromise = wrapper.connect().then(() => {
       onReadyCb();
 
-      // Start periodic flush of async storages
-      if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-      if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
-
-      // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
-      if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig && mode) (telemetry as ITelemetryCacheAsync).recordConfig();
+      // Start periodic flush of async storages if not running synchronizer (producer mode)
+      if (!isSyncronizer) {
+        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+        if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+      }
     }).catch((e) => {
       e = e || new Error('Error connecting wrapper');
       onReadyCb(e);
@@ -102,9 +111,9 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       telemetry,
       uniqueKeys: uniqueKeysCache,
 
-      // Disconnect the underlying storage
+      // Stop periodic flush and disconnect the underlying storage
       destroy() {
-        return Promise.all([
+        return Promise.all(isSyncronizer ? [] : [
           impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).stop && (impressionCountsCache as ImpressionCountsCachePluggable).stop(),
           uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).stop && (uniqueKeysCache as UniqueKeysCachePluggable).stop(),
         ]).then(() => wrapper.disconnect());

package/src/storages/types.ts

@@ -349,12 +349,12 @@ 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
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
+  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
 }
 
 export interface IUniqueKeysCacheBase {

package/src/sync/submitters/types.ts

@@ -37,13 +37,15 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
+export type UniqueKeysItemSs = {
+  /** Split name */
+  f: string
+  /** keyNames */
+  ks: string[]
+}
+
 export type UniqueKeysPayloadSs = {
-  keys: {
-    /** Split name */
-    f: string
-    /** keyNames */
-    ks: string[]
-  }[]
+  keys: UniqueKeysItemSs[]
 }
 
 export type UniqueKeysPayloadCs = {

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

@@ -1,21 +1,25 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { ISet } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export declare function fromUniqueKeysCollector(uniqueKeys: {
+    [featureName: string]: ISet<string>;
+}): UniqueKeysPayloadSs;
 export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     protected onFullQueue?: () => void;
     private readonly maxStorage;
     private uniqueTrackerSize;
     protected uniqueKeysTracker: {
-        [keys: string]: ISet<string>;
+        [featureName: string]: ISet<string>;
     };
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;
     /**
-     * Store unique keys in sequential order
-     * key: string = feature name.
-     * value: Set<string> = set of unique keys.
+     * Store unique keys per feature.
      */
-    track(key: string, featureName: string): void;
+    track(userKey: string, featureName: string): void;
     /**
      * Clear the data stored on the cache.
      */
@@ -28,8 +32,4 @@ export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
      * Check if the cache is empty.
      */
     isEmpty(): boolean;
-    /**
-     * Converts `uniqueKeys` data from cache into request payload for SS.
-     */
-    private fromUniqueKeysCollector;
 }

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

@@ -13,11 +13,9 @@ export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;
     /**
-     * Store unique keys in sequential order
-     * key: string = key.
-     * value: HashSet<string> = set of split names.
+     * Store unique keys per feature.
      */
-    track(key: string, featureName: string): void;
+    track(userKey: string, featureName: string): void;
     /**
      * Clear the data stored on the cache.
      */

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

@@ -1,5 +1,6 @@
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
     private readonly log;
@@ -11,4 +12,5 @@ export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheI
     private postImpressionCountsInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
 }

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

@@ -2,6 +2,7 @@ import { IUniqueKeysCacheBase } from '../types';
 import { Redis } from 'ioredis';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
 export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     private readonly log;
     private readonly key;
@@ -12,4 +13,9 @@ export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory impl
     private postUniqueKeysInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    /**
+     * 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.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
 }

package/types/storages/pluggable/ImpressionCountsCachePluggable.d.ts

@@ -1,4 +1,5 @@
 import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { IPluggableStorageWrapper } from '../types';
 export declare class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
@@ -11,4 +12,5 @@ export declare class ImpressionCountsCachePluggable extends ImpressionCountsCach
     private storeImpressionCounts;
     start(): void;
     stop(): Promise<any>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
 }

package/types/storages/pluggable/UniqueKeysCachePluggable.d.ts

@@ -1,6 +1,7 @@
 import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
 export declare class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     private readonly log;
     private readonly key;
@@ -11,4 +12,9 @@ export declare class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory im
     storeUniqueKeys(): Promise<any>;
     start(): void;
     stop(): Promise<any>;
+    /**
+     * 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.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
 }

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

@@ -33,13 +33,14 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
+export declare type UniqueKeysItemSs = {
+    /** Split name */
+    f: string;
+    /** keyNames */
+    ks: string[];
+};
 export declare type UniqueKeysPayloadSs = {
-    keys: {
-        /** Split name */
-        f: string;
-        /** keyNames */
-        ks: string[];
-    }[];
+    keys: UniqueKeysItemSs[];
 };
 export declare type UniqueKeysPayloadCs = {
     keys: {