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

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCachePluggable = void 0;
 var findLatencyIndex_1 = require("../findLatencyIndex");
+var telemetrySubmitter_1 = require("../../sync/submitters/telemetrySubmitter");
+var constants_1 = require("../../utils/constants");
+var lang_1 = require("../../utils/lang");
+var maps_1 = require("../../utils/lang/maps");
+var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var utils_1 = require("../utils");
 var TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.
@@ -22,6 +28,126 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.incr(this.keys.buildExceptionKey(method))
             .catch(function () { });
     };
+    TelemetryCachePluggable.prototype.recordConfig = function () {
+        var value = JSON.stringify((0, telemetrySubmitter_1.getTelemetryConfigStats)(constants_1.CONSUMER_MODE, constants_1.STORAGE_PLUGGABLE));
+        return this.wrapper.set(this.keys.buildInitKey(), value).catch(function () { });
+    };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popLatencies = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
+            return latencyKeys.length ?
+                _this.wrapper.getMany(latencyKeys).then(function (latencies) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < latencyKeys.length; i++) {
+                        var field = latencyKeys[i].split('::')[1];
+                        var parsedField = (0, utils_1.parseLatencyField)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(latencies[i]);
+                        if ((0, lang_1.isNaNNumber)(count)) {
+                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            continue;
+                        }
+                        var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                        if (bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT) {
+                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            continue;
+                        }
+                        if (!result.has(metadata))
+                            result.set(metadata, {
+                                t: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                                ts: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                                tc: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                                tcs: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                                tr: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                            });
+                        result.get(metadata)[method][bucket] = count;
+                    }
+                    return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
+                }) :
+                // If latencyKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popExceptions = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
+            return exceptionKeys.length ?
+                _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < exceptionKeys.length; i++) {
+                        var field = exceptionKeys[i].split('::')[1];
+                        var parsedField = (0, utils_1.parseExceptionField)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(exceptions[i]);
+                        if ((0, lang_1.isNaNNumber)(count)) {
+                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            continue;
+                        }
+                        var metadata = parsedField[0], method = parsedField[1];
+                        if (!result.has(metadata))
+                            result.set(metadata, {
+                                t: 0,
+                                ts: 0,
+                                tc: 0,
+                                tcs: 0,
+                                tr: 0,
+                            });
+                        result.get(metadata)[method] = count;
+                    }
+                    return Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
+                }) :
+                // If exceptionKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popConfigs = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
+            return configKeys.length ?
+                _this.wrapper.getMany(configKeys).then(function (configs) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < configKeys.length; i++) {
+                        var field = configKeys[i].split('::')[1];
+                        var parsedField = (0, utils_1.parseMetadata)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        var metadata = parsedField[0];
+                        try { // @ts-ignore
+                            var config = JSON.parse(configs[i]);
+                            result.set(metadata, config);
+                        }
+                        catch (e) {
+                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                        }
+                    }
+                    return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
+                }) :
+                // If configKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
     return TelemetryCachePluggable;
 }());
 exports.TelemetryCachePluggable = TelemetryCachePluggable;

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueKeysCachePluggable = void 0;
+var tslib_1 = require("tslib");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
+var sets_1 = require("../../utils/lang/sets");
+var constants_1 = require("../inRedis/constants");
+var constants_2 = require("./constants");
+var UniqueKeysCachePluggable = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(UniqueKeysCachePluggable, _super);
+    function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.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 = (0, sets_1.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(constants_2.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_1.UniqueKeysCacheInMemory));
+exports.UniqueKeysCachePluggable = UniqueKeysCachePluggable;

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -37,29 +37,31 @@ function inMemoryWrapperFactory(connDelay) {
         getKeysByPrefix: function (prefix) {
             return Promise.resolve(Object.keys(_cache).filter(function (key) { return (0, lang_1.startsWith)(key, prefix); }));
         },
-        incr: function (key) {
+        incr: function (key, increment) {
+            if (increment === void 0) { increment = 1; }
             if (key in _cache) {
-                var count = (0, lang_1.toNumber)(_cache[key]) + 1;
+                var count = (0, lang_1.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 = (0, lang_1.toNumber)(_cache[key]) - 1;
+                var count = (0, lang_1.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/cjs/storages/pluggable/index.js

@@ -14,6 +14,13 @@ var constants_1 = require("../../utils/constants");
 var ImpressionsCacheInMemory_1 = require("../inMemory/ImpressionsCacheInMemory");
 var EventsCacheInMemory_1 = require("../inMemory/EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCacheInMemory");
+var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var TelemetryCachePluggable_1 = require("./TelemetryCachePluggable");
+var ImpressionCountsCachePluggable_1 = require("./ImpressionCountsCachePluggable");
+var UniqueKeysCachePluggable_1 = require("./UniqueKeysCachePluggable");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
+var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
+var utils_1 = require("../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.';
 /**
@@ -30,15 +37,6 @@ function validatePluggableStorageOptions(options) {
     if (missingMethods.length)
         throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
 }
-// subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper, onReadyCb) {
-    wrapper.connect().then(function () {
-        onReadyCb();
-        // At the moment, we don't synchronize config with pluggable storage
-    }).catch(function (e) {
-        onReadyCb(e || new Error('Error connecting wrapper'));
-    });
-}
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
 function promisifyEventsTrack(events) {
@@ -54,28 +52,63 @@ function promisifyEventsTrack(events) {
 function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
-    function PluggableStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, impressionsQueueSize = _a.impressionsQueueSize, optimize = _a.optimize;
+    function PluggableStorageFactory(params) {
+        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 = (0, utils_1.metadataBuilder)(settings);
         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) || isSyncronizer ?
+            isPartialConsumer ?
+                new TelemetryCacheInMemory_1.TelemetryCacheInMemory() :
+                new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
+            undefined;
+        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 || isSyncronizer ?
+            isPartialConsumer ?
+                settings.core.key === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
+                new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
-        wrapperConnect(wrapper, onReadyCb);
+        var connectPromise = wrapper.connect().then(function () {
+            onReadyCb();
+            // 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);
+            return e;
+        });
         return {
             splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-            impressionCounts: optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+            impressionCounts: impressionCountsCache,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
-            // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
-            // Disconnect the underlying storage
+            telemetry: telemetry,
+            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) {
-                wrapperConnect(wrapper, onReadyCb);
+                connectPromise.then(onReadyCb);
                 return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

package/cjs/storages/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+// Shared utils for Redis and Pluggable storage
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLatencyField = exports.parseExceptionField = exports.parseMetadata = exports.impressionsToJSON = exports.metadataBuilder = void 0;
+var constants_1 = require("../utils/constants");
+var TelemetryCacheInMemory_1 = require("./inMemory/TelemetryCacheInMemory");
+var KeyBuilderSS_1 = require("./KeyBuilderSS");
+function metadataBuilder(settings) {
+    return {
+        s: settings.version,
+        i: settings.runtime.ip || constants_1.UNKNOWN,
+        n: settings.runtime.hostname || constants_1.UNKNOWN,
+    };
+}
+exports.metadataBuilder = metadataBuilder;
+// Converts impressions to be stored in Redis or pluggable storage.
+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);
+    });
+}
+exports.impressionsToJSON = impressionsToJSON;
+// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
+var REVERSE_METHOD_NAMES = Object.keys(KeyBuilderSS_1.METHOD_NAMES).reduce(function (acc, key) {
+    acc[KeyBuilderSS_1.METHOD_NAMES[key]] = key;
+    return acc;
+}, {});
+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 })];
+}
+exports.parseMetadata = parseMetadata;
+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];
+}
+exports.parseExceptionField = parseExceptionField;
+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 >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT)
+        return "invalid bucket. Expected a number between 0 and " + (TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}
+exports.parseLatencyField = parseLatencyField;

package/cjs/sync/submitters/submitterManager.js

@@ -15,7 +15,7 @@ function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
-    if (params.uniqueKeysTracker)
+    if (params.storage.uniqueKeys)
         submitters.push((0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.getTelemetryConfigStats = exports.telemetryCacheStatsAdapter = void 0;
+exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.getTelemetryConfigStats = void 0;
 var submitter_1 = require("./submitter");
 var constants_1 = require("../../utils/constants");
 var constants_2 = require("../../readiness/constants");
@@ -9,39 +9,6 @@ var settingsValidation_1 = require("../../utils/settingsValidation");
 var apiKey_1 = require("../../utils/inputValidation/apiKey");
 var timer_1 = require("../../utils/timeTracker/timer");
 var objectAssign_1 = require("../../utils/lang/objectAssign");
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-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(constants_1.QUEUED),
-                iDe: telemetry.getImpressionStats(constants_1.DEDUPED),
-                iDr: telemetry.getImpressionStats(constants_1.DROPPED),
-                spC: splits.getSplitNames().length,
-                seC: segments.getRegisteredSegments().length,
-                skC: segments.getKeysCount(),
-                sL: telemetry.getSessionLength(),
-                eQ: telemetry.getEventStats(constants_1.QUEUED),
-                eD: telemetry.getEventStats(constants_1.DROPPED),
-                sE: telemetry.popStreamingEvents(),
-                t: telemetry.popTags(),
-            };
-        }
-    };
-}
-exports.telemetryCacheStatsAdapter = telemetryCacheStatsAdapter;
 var OPERATION_MODE_MAP = (_a = {},
     _a[constants_1.STANDALONE_MODE] = constants_1.STANDALONE_ENUM,
     _a[constants_1.CONSUMER_MODE] = constants_1.CONSUMER_ENUM,
@@ -121,12 +88,12 @@ exports.telemetryCacheConfigAdapter = telemetryCacheConfigAdapter;
  * Submitter that periodically posts telemetry data
  */
 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 = (0, timer_1.timer)(now);
-    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/cjs/sync/submitters/uniqueKeysSubmitter.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.uniqueKeysSubmitterFactory = void 0;
 var constants_1 = require("../../logger/constants");
 var submitter_1 = require("./submitter");
-var DATA_NAME = 'uniqueKeys';
+var DATA_NAME = 'unique keys';
+var UNIQUE_KEYS_RATE = 900000; // 15 minutes
 /**
  * Submitter that periodically posts impression counts
  */
 function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    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 = (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys');
+    var syncTask = (0, submitter_1.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()) {

package/cjs/trackers/impressionObserver/utils.js

@@ -1,23 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStorageSync = exports.shouldBeOptimized = exports.shouldAddPt = void 0;
+exports.isStorageSync = void 0;
 var constants_1 = require("../../utils/constants");
-/**
- * Checks if impressions previous time should be added or not.
- */
-function shouldAddPt(settings) {
-    return [constants_1.PRODUCER_MODE, constants_1.STANDALONE_MODE, constants_1.CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-exports.shouldAddPt = shouldAddPt;
-/**
- * Checks if it should dedupe impressions or not.
- */
-function shouldBeOptimized(settings) {
-    if (!shouldAddPt(settings))
-        return false;
-    return settings.sync.impressionsMode === constants_1.OPTIMIZED ? true : false;
-}
-exports.shouldBeOptimized = shouldBeOptimized;
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/cjs/trackers/uniqueKeysTracker.js

@@ -10,7 +10,7 @@ var noopFilterAdapter = {
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
  * @param uniqueKeysCache cache to save unique keys

package/cjs/utils/lang/maps.js

@@ -40,13 +40,6 @@ var MapPoly = /** @class */ (function () {
         this.__mapKeysData__.length = 0;
         this.__mapValuesData__.length = 0;
     };
-    MapPoly.prototype.set = function (key, value) {
-        var index = this.__mapKeysData__.indexOf(key);
-        if (index === -1)
-            index = this.__mapKeysData__.push(key) - 1;
-        this.__mapValuesData__[index] = value;
-        return this;
-    };
     MapPoly.prototype.delete = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
@@ -55,12 +48,27 @@ var MapPoly = /** @class */ (function () {
         this.__mapValuesData__.splice(index, 1);
         return true;
     };
+    MapPoly.prototype.forEach = function (callbackfn, thisArg) {
+        for (var i = 0; i < this.__mapKeysData__.length; i++) {
+            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);
+        }
+    };
     MapPoly.prototype.get = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
             return;
         return this.__mapValuesData__[index];
     };
+    MapPoly.prototype.has = function (key) {
+        return this.__mapKeysData__.indexOf(key) !== -1;
+    };
+    MapPoly.prototype.set = function (key, value) {
+        var index = this.__mapKeysData__.indexOf(key);
+        if (index === -1)
+            index = this.__mapKeysData__.push(key) - 1;
+        this.__mapValuesData__[index] = value;
+        return this;
+    };
     Object.defineProperty(MapPoly.prototype, "size", {
         get: function () {
             return this.__mapKeysData__.length;

package/cjs/utils/redis/RedisMock.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisMock = void 0;
+//@ts-nocheck
+function identityFunction(data) {
+    return data;
+}
+function asyncFunction(data) {
+    return Promise.resolve(data);
+}
+var IDENTITY_METHODS = [];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var RedisMock = /** @class */ (function () {
+    function RedisMock() {
+        var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
+        IDENTITY_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(identityFunction);
+        });
+        ASYNC_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(asyncFunction);
+        });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
+    }
+    return RedisMock;
+}());
+exports.RedisMock = RedisMock;