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

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -200,7 +200,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-     * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
      *
      * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
      */

package/esm/storages/inLocalStorage/index.js

@@ -11,8 +11,10 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -22,25 +24,31 @@ export function InLocalStorage(options) {
     function InLocalStorageCSFactory(params) {
         // Fallback to InMemoryStorage if LocalStorage API is not available
         if (!isLocalStorageAvailable()) {
-            params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+            params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
-        var log = params.log;
-        var keys = new KeyBuilderCS(prefix, params.matchingKey);
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var matchingKey = getMatching(settings.core.key);
+        var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        var splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+        var segments = new MySegmentsCacheInLocal(log, keys);
         return {
-            splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-            segments: new MySegmentsCacheInLocal(log, keys),
-            impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-            impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-            events: new EventsCacheInMemory(params.eventsQueueSize),
-            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+            splits: splits,
+            segments: segments,
+            impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+            impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+            events: new EventsCacheInMemory(eventsQueueSize),
+            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+            uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
+                var _a;
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
+                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {

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

@@ -3,28 +3,35 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
+    var segments = new SegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory(),
-        segments: new SegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory(eventsQueueSize),
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         }
     };
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,28 +3,35 @@ import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
+    var segments = new MySegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory(),
-        segments: new MySegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory(eventsQueueSize),
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,39 +1,67 @@
-import { LOCALHOST_MODE } from '../../utils/constants';
+import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
 export var MAX_LATENCY_BUCKET_COUNT = 23;
 export function newBuckets() {
-    return new Array(MAX_LATENCY_BUCKET_COUNT).fill(0);
+    // MAX_LATENCY_BUCKET_COUNT (length) is 23
+    // Not using Array.fill for old browsers compatibility
+    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 }
 var ACCEPTANCE_RANGE = 0.001;
 /**
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry(params) {
-    return params.mode !== LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
+export function shouldRecordTelemetry(_a) {
+    var settings = _a.settings;
+    return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory() {
+    function TelemetryCacheInMemory(splits, segments) {
+        this.splits = splits;
+        this.segments = segments;
+        // isEmpty flag
+        this.e = true;
         this.notReadyUsage = 0;
+        /** Usage stats */
         this.impressionStats = [0, 0, 0];
         this.eventStats = [0, 0];
-        // @ts-expect-error
         this.lastSync = {};
-        // @ts-expect-error
         this.httpErrors = {};
-        // @ts-expect-error
         this.httpLatencies = {};
         this.authRejections = 0;
         this.tokenRefreshes = 0;
         this.streamingEvents = [];
         this.tags = [];
-        // @ts-expect-error
         this.exceptions = {};
-        // @ts-expect-error
         this.latencies = {};
     }
+    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
+    TelemetryCacheInMemory.prototype.clear = function () { };
+    TelemetryCacheInMemory.prototype.pop = function () {
+        this.e = true;
+        return {
+            lS: this.getLastSynchronization(),
+            mL: this.popLatencies(),
+            mE: this.popExceptions(),
+            hE: this.popHttpErrors(),
+            hL: this.popHttpLatencies(),
+            tR: this.popTokenRefreshes(),
+            aR: this.popAuthRejections(),
+            iQ: this.getImpressionStats(QUEUED),
+            iDe: this.getImpressionStats(DEDUPED),
+            iDr: this.getImpressionStats(DROPPED),
+            spC: this.splits && this.splits.getSplitNames().length,
+            seC: this.segments && this.segments.getRegisteredSegments().length,
+            skC: this.segments && this.segments.getKeysCount(),
+            sL: this.getSessionLength(),
+            eQ: this.getEventStats(QUEUED),
+            eD: this.getEventStats(DROPPED),
+            sE: this.popStreamingEvents(),
+            t: this.popTags(),
+        };
+    };
     TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
         return this.timeUntilReady;
     };
@@ -57,44 +85,41 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
         this.impressionStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getEventStats = function (type) {
         return this.eventStats[type];
     };
     TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
         this.eventStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
         return this.lastSync;
     };
     TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
         this.lastSync[resource] = timeMs;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpErrors = function () {
-        var result = this.httpErrors; // @ts-expect-error
+        var result = this.httpErrors;
         this.httpErrors = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
-        if (!this.httpErrors[resource])
-            this.httpErrors[resource] = {};
-        if (!this.httpErrors[resource][status]) {
-            this.httpErrors[resource][status] = 1;
-        }
-        else {
-            this.httpErrors[resource][status]++;
-        }
+        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
+        statusErrors[status] = (statusErrors[status] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
-        var result = this.httpLatencies; // @ts-expect-error
+        var result = this.httpLatencies;
         this.httpLatencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
-        if (!this.httpLatencies[resource]) {
-            this.httpLatencies[resource] = newBuckets();
-        }
-        this.httpLatencies[resource][findLatencyIndex(latencyMs)]++;
+        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
+        latencyBuckets[findLatencyIndex(latencyMs)]++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popAuthRejections = function () {
         var result = this.authRejections;
@@ -103,6 +128,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
         this.authRejections++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
         var result = this.tokenRefreshes;
@@ -111,6 +137,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
         this.tokenRefreshes++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
         return this.streamingEvents.splice(0);
@@ -119,6 +146,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
             this.streamingEvents.push(streamingEvent);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTags = function () {
         return this.tags.splice(0);
@@ -127,36 +155,33 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.tags.length < MAX_TAGS) {
             this.tags.push(tag);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getSessionLength = function () {
         return this.sessionLength;
     };
     TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
         this.sessionLength = ms;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popExceptions = function () {
-        var result = this.exceptions; // @ts-expect-error
+        var result = this.exceptions;
         this.exceptions = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordException = function (method) {
-        if (!this.exceptions[method]) {
-            this.exceptions[method] = 1;
-        }
-        else {
-            this.exceptions[method]++;
-        }
+        this.exceptions[method] = (this.exceptions[method] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popLatencies = function () {
-        var result = this.latencies; // @ts-expect-error
+        var result = this.latencies;
         this.latencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
-        if (!this.latencies[method]) {
-            this.latencies[method] = newBuckets();
-        }
-        this.latencies[method][findLatencyIndex(latencyMs)]++;
+        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
+        latencyBuckets[findLatencyIndex(latencyMs)]++;
+        this.e = false;
     };
     return TelemetryCacheInMemory;
 }());

package/esm/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -0,0 +1,68 @@
+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; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys per feature.
+     */
+    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
+        if (!this.uniqueKeysTracker[featureName])
+            this.uniqueKeysTracker[featureName] = new _Set();
+        var tracker = this.uniqueKeysTracker[featureName];
+        if (!tracker.has(userKey)) {
+            tracker.add(userKey);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemory.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemory.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    return UniqueKeysCacheInMemory;
+}());
+export { UniqueKeysCacheInMemory };

package/esm/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,73 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys per feature.
+     */
+    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++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var userKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < userKeys.length; k++) {
+            var userKey = userKeys[k];
+            var featureNames = setToArray(uniqueKeys[userKey]);
+            var uniqueKeysPayload = {
+                k: userKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+export { UniqueKeysCacheInMemoryCS };

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,82 @@
+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) {
+    __extends(ImpressionCountsCacheInRedis, _super);
+    function ImpressionCountsCacheInRedis(log, key, redis, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.postImpressionCountsInRedis(); };
+        return _this;
+    }
+    ImpressionCountsCacheInRedis.prototype.postImpressionCountsInRedis = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        if (!keys.length)
+            return Promise.resolve(false);
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        return pipeline.exec()
+            .then(function (data) {
+            // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+            if (data.length && data.length === keys.length) {
+                return _this.redis.expire(_this.key, TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCacheInRedis.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.postImpressionCountsInRedis();
+    };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCacheInRedis.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.redis.hgetall(this.key)
+            .then(function (counts) {
+            if (!Object.keys(counts).length)
+                return undefined;
+            _this.redis.del(_this.key).catch(function () { });
+            var pf = [];
+            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;
+                }
+                pf.push({
+                    f: nameAndTime[0],
+                    m: timeFrame,
+                    rc: rawCount,
+                });
+            });
+            return { pf: pf };
+        });
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory));
+export { ImpressionCountsCacheInRedis };

package/esm/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,3 +1,4 @@
+import { impressionsToJSON } from '../utils';
 var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 var ImpressionsCacheInRedis = /** @class */ (function () {
     function ImpressionsCacheInRedis(log, key, redis, metadata) {
@@ -8,31 +9,13 @@ var ImpressionsCacheInRedis = /** @class */ (function () {
     }
     ImpressionsCacheInRedis.prototype.track = function (impressions) {
         var _this = this;
-        return this.redis.rpush(this.key, this._toJSON(impressions)).then(function (queuedCount) {
+        return this.redis.rpush(this.key, impressionsToJSON(impressions, this.metadata)).then(function (queuedCount) {
             // If this is the creation of the key on Redis, set the expiration for it in 1hr.
             if (queuedCount === impressions.length) {
                 return _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH);
             }
         });
     };
-    ImpressionsCacheInRedis.prototype._toJSON = function (impressions) {
-        var _this = this;
-        return impressions.map(function (impression) {
-            var keyName = impression.keyName, bucketingKey = impression.bucketingKey, feature = impression.feature, treatment = impression.treatment, label = impression.label, time = impression.time, changeNumber = impression.changeNumber;
-            return JSON.stringify({
-                m: _this.metadata,
-                i: {
-                    k: keyName,
-                    b: bucketingKey,
-                    f: feature,
-                    t: treatment,
-                    r: label,
-                    c: changeNumber,
-                    m: time
-                }
-            });
-        });
-    };
     ImpressionsCacheInRedis.prototype.count = function () {
         return this.redis.llen(this.key).catch(function () { return 0; });
     };

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,10 +1,10 @@
-import { parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
 import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
+import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.