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

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -0,0 +1,68 @@
+import { __extends } from "tslib";
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
+import { LOG_PREFIX } from './constants';
+var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
+    __extends(UniqueKeysCacheInRedis, _super);
+    function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.postUniqueKeysInRedis(); };
+        return _this;
+    }
+    UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
+        var _this = this;
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames.length)
+            return Promise.resolve(false);
+        var pipeline = this.redis.pipeline();
+        for (var i = 0; i < featureNames.length; i++) {
+            var featureName = featureNames[i];
+            var featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            pipeline.rpush(this.key, JSON.stringify(uniqueKeysPayload));
+        }
+        this.clear();
+        return pipeline.exec()
+            .then(function (data) {
+            // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+            if (data.length && data.length === featureNames.length) {
+                return _this.redis.expire(_this.key, TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            return false;
+        });
+    };
+    UniqueKeysCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
+    };
+    UniqueKeysCacheInRedis.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.postUniqueKeysInRedis();
+    };
+    /**
+     * 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/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,11 @@ 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';
+import { metadataBuilder } from '../utils';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -14,14 +17,21 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 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;
+    function InRedisStorageFactory(params) {
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
+        var metadata = metadataBuilder(settings);
         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 +39,19 @@ export function InRedisStorage(options) {
             splits: new SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
+            impressionCounts: impressionCountsCache,
             events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
             telemetry: telemetry,
+            uniqueKeys: uniqueKeysCache,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                redisClient.disconnect();
+                var promises = [];
+                if (impressionCountsCache)
+                    promises.push(impressionCountsCache.stop());
+                if (uniqueKeysCache)
+                    promises.push(uniqueKeysCache.stop());
+                return Promise.all(promises).then(function () { redisClient.disconnect(); });
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/esm/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -0,0 +1,78 @@
+import { __extends } from "tslib";
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { REFRESH_RATE } from '../inRedis/constants';
+import { LOG_PREFIX } from './constants';
+var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
+    __extends(ImpressionCountsCachePluggable, _super);
+    function ImpressionCountsCachePluggable(log, key, wrapper, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeImpressionCounts(); };
+        return _this;
+    }
+    ImpressionCountsCachePluggable.prototype.storeImpressionCounts = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        if (!keys.length)
+            return Promise.resolve(false);
+        var pipeline = keys.reduce(function (pipeline, key) {
+            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+        }, Promise.resolve());
+        return pipeline.catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCachePluggable.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.storeImpressionCounts();
+    };
+    // 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 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;
+                    }
+                    pf.push({
+                        f: keyFeatureNameAndTime[1],
+                        m: timeFrame,
+                        rc: rawCount,
+                    });
+                }
+                return { pf: pf };
+            }) : undefined;
+        });
+    };
+    return ImpressionCountsCachePluggable;
+}(ImpressionCountsCacheInMemory));
+export { ImpressionCountsCachePluggable };

package/esm/storages/pluggable/ImpressionsCachePluggable.js

@@ -1,3 +1,4 @@
+import { impressionsToJSON } from '../utils';
 var ImpressionsCachePluggable = /** @class */ (function () {
     function ImpressionsCachePluggable(log, key, wrapper, metadata) {
         this.log = log;
@@ -12,25 +13,7 @@ var ImpressionsCachePluggable = /** @class */ (function () {
      * or rejected if the wrapper operation fails.
      */
     ImpressionsCachePluggable.prototype.track = function (impressions) {
-        return this.wrapper.pushItems(this.key, this._toJSON(impressions));
-    };
-    ImpressionsCachePluggable.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
-                }
-            });
-        });
+        return this.wrapper.pushItems(this.key, impressionsToJSON(impressions, this.metadata));
     };
     /**
      * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.

package/esm/storages/pluggable/TelemetryCachePluggable.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_PLUGGABLE } from '../../utils/constants';
 import { isString, isNaNNumber } 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 TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -0,0 +1,58 @@
+import { __extends } from "tslib";
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
+import { LOG_PREFIX } from './constants';
+var UniqueKeysCachePluggable = /** @class */ (function (_super) {
+    __extends(UniqueKeysCachePluggable, _super);
+    function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeUniqueKeys(); };
+        return _this;
+    }
+    UniqueKeysCachePluggable.prototype.storeUniqueKeys = function () {
+        var _this = this;
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames.length)
+            return Promise.resolve(false);
+        var pipeline = featureNames.reduce(function (pipeline, featureName) {
+            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            return pipeline.then(function () { return _this.wrapper.pushItems(_this.key, [JSON.stringify(uniqueKeysPayload)]); });
+        }, Promise.resolve());
+        this.clear();
+        return pipeline.catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            return false;
+        });
+    };
+    UniqueKeysCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeUniqueKeys.bind(this), this.refreshRate);
+    };
+    UniqueKeysCachePluggable.prototype.stop = function () {
+        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/inMemoryWrapper.js

@@ -34,29 +34,31 @@ export function inMemoryWrapperFactory(connDelay) {
         getKeysByPrefix: function (prefix) {
             return Promise.resolve(Object.keys(_cache).filter(function (key) { return startsWith(key, prefix); }));
         },
-        incr: function (key) {
+        incr: function (key, increment) {
+            if (increment === void 0) { increment = 1; }
             if (key in _cache) {
-                var count = toNumber(_cache[key]) + 1;
+                var count = toNumber(_cache[key]) + increment;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '1';
+                _cache[key] = '' + increment;
                 return Promise.resolve(1);
             }
         },
-        decr: function (key) {
+        decr: function (key, decrement) {
+            if (decrement === void 0) { decrement = 1; }
             if (key in _cache) {
-                var count = toNumber(_cache[key]) - 1;
+                var count = toNumber(_cache[key]) - decrement;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '-1';
+                _cache[key] = '-' + decrement;
                 return Promise.resolve(-1);
             }
         },

package/esm/storages/pluggable/index.js

@@ -7,12 +7,17 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { validatePrefix } from '../KeyBuilder';
-import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { TelemetryCachePluggable } from './TelemetryCachePluggable';
+import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable';
+import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { metadataBuilder } from '../utils';
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**
@@ -45,19 +50,39 @@ export function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = validatePrefix(options.prefix);
     function PluggableStorageFactory(params) {
-        var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, optimize = params.optimize;
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, mode = _a.mode, impressionsMode = _a.sync.impressionsMode, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
+        var metadata = metadataBuilder(settings);
         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 || isSyncronizer ?
+            isPartialConsumer ?
+                new ImpressionCountsCacheInMemory() :
+                new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+            undefined;
+        var uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
+            isPartialConsumer ?
+                settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+                new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
             undefined;
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
             onReadyCb();
-            // 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);
@@ -67,12 +92,16 @@ export function PluggableStorage(options) {
             splits: new SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-            impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
+            impressionCounts: impressionCountsCache,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
-            // Disconnect the underlying storage
+            uniqueKeys: uniqueKeysCache,
+            // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
-                return wrapper.disconnect();
+                return Promise.all(isSyncronizer ? [] : [
+                    impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
+                    uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
+                ]).then(function () { return wrapper.disconnect(); });
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {

package/esm/storages/utils.js

@@ -0,0 +1,65 @@
+// Shared utils for Redis and Pluggable storage
+import { UNKNOWN } from '../utils/constants';
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+import { METHOD_NAMES } from './KeyBuilderSS';
+export function metadataBuilder(settings) {
+    return {
+        s: settings.version,
+        i: settings.runtime.ip || UNKNOWN,
+        n: settings.runtime.hostname || UNKNOWN,
+    };
+}
+// Converts impressions to be stored in Redis or pluggable storage.
+export function impressionsToJSON(impressions, metadata) {
+    return impressions.map(function (impression) {
+        var impressionWithMetadata = {
+            m: metadata,
+            i: {
+                k: impression.keyName,
+                b: impression.bucketingKey,
+                f: impression.feature,
+                t: impression.treatment,
+                r: impression.label,
+                c: impression.changeNumber,
+                m: impression.time,
+                pt: impression.pt,
+            }
+        };
+        return JSON.stringify(impressionWithMetadata);
+    });
+}
+// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
+var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
+    acc[METHOD_NAMES[key]] = key;
+    return acc;
+}, {});
+export function parseMetadata(field) {
+    var parts = field.split('/');
+    if (parts.length !== 3)
+        return "invalid subsection count. Expected 3, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
+    return [JSON.stringify({ s: s, n: n, i: i })];
+}
+export function parseExceptionField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 4)
+        return "invalid subsection count. Expected 4, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    return [JSON.stringify({ s: s, n: n, i: i }), method];
+}
+export function parseLatencyField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 5)
+        return "invalid subsection count. Expected 5, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    var bucket = parseInt(b);
+    if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
+        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}

package/esm/sync/submitters/submitterManager.js

@@ -2,6 +2,7 @@ import { eventsSubmitterFactory } from './eventsSubmitter';
 import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
+import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 export function submitterManagerFactory(params) {
     var submitters = [
         impressionsSubmitterFactory(params),
@@ -11,6 +12,8 @@ export function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = telemetrySubmitterFactory(params);
+    if (params.storage.uniqueKeys)
+        submitters.push(uniqueKeysSubmitterFactory(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
         start: function (onlyTelemetry) {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,44 +1,11 @@
 var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { objectAssign } from '../../utils/lang/objectAssign';
-import { isStorageSync } from '../../trackers/impressionObserver/utils';
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-export function telemetryCacheStatsAdapter(telemetry, splits, segments) {
-    return {
-        isEmpty: function () { return false; },
-        clear: function () { },
-        // @TODO consider moving inside telemetry cache for code size reduction
-        pop: function () {
-            return {
-                lS: telemetry.getLastSynchronization(),
-                mL: telemetry.popLatencies(),
-                mE: telemetry.popExceptions(),
-                hE: telemetry.popHttpErrors(),
-                hL: telemetry.popHttpLatencies(),
-                tR: telemetry.popTokenRefreshes(),
-                aR: telemetry.popAuthRejections(),
-                iQ: telemetry.getImpressionStats(QUEUED),
-                iDe: telemetry.getImpressionStats(DEDUPED),
-                iDr: telemetry.getImpressionStats(DROPPED),
-                spC: splits && splits.getSplitNames().length,
-                seC: segments && segments.getRegisteredSegments().length,
-                skC: segments && segments.getKeysCount(),
-                sL: telemetry.getSessionLength(),
-                eQ: telemetry.getEventStats(QUEUED),
-                eD: telemetry.getEventStats(DROPPED),
-                sE: telemetry.popStreamingEvents(),
-                t: telemetry.popTags(),
-            };
-        }
-    };
-}
 var OPERATION_MODE_MAP = (_a = {},
     _a[STANDALONE_MODE] = STANDALONE_ENUM,
     _a[CONSUMER_MODE] = CONSUMER_ENUM,
@@ -47,6 +14,7 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
+    _b[NONE] = NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[CONSENT_UNKNOWN] = 1,
@@ -115,14 +83,12 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, 
-    // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
-    isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -0,0 +1,23 @@
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { submitterFactory } from './submitter';
+var DATA_NAME = 'unique keys';
+var UNIQUE_KEYS_RATE = 900000; // 15 minutes
+/**
+ * Submitter that periodically posts impression counts
+ */
+export function uniqueKeysSubmitterFactory(params) {
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var isClientSide = key !== undefined;
+    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
+    // register unique keys submitter to be executed when uniqueKeys cache is full
+    uniqueKeys.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
+}

package/esm/trackers/impressionObserver/utils.js

@@ -1,18 +1,4 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
-/**
- * Checks if impressions previous time should be added or not.
- */
-export function shouldAddPt(settings) {
-    return [PRODUCER_MODE, STANDALONE_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-/**
- * Checks if it should dedupe impressions or not.
- */
-export function shouldBeOptimized(settings) {
-    if (!shouldAddPt(settings))
-        return false;
-    return settings.sync.impressionsMode === OPTIMIZED ? true : false;
-}
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
 /**
  * Storage is async if mode is consumer or partial consumer
  */