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

package/cjs/storages/inRedis/constants.js

@@ -1,7 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TTL_REFRESH = exports.REFRESH_RATE = exports.DEFAULT_CACHE_SIZE = exports.LOG_PREFIX = void 0;
+exports.LOG_PREFIX = void 0;
 exports.LOG_PREFIX = 'storage:redis: ';
-exports.DEFAULT_CACHE_SIZE = 30000;
-exports.REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
-exports.TTL_REFRESH = 3600; // 1hr

package/cjs/storages/inRedis/index.js

@@ -10,8 +10,6 @@ var ImpressionsCacheInRedis_1 = require("./ImpressionsCacheInRedis");
 var EventsCacheInRedis_1 = require("./EventsCacheInRedis");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
-var uniqueKeysCacheInRedis_1 = require("./uniqueKeysCacheInRedis");
-var ImpressionCountsCacheInRedis_1 = require("./ImpressionCountsCacheInRedis");
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -20,19 +18,13 @@ function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     function InRedisStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter_1.RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
-        var impressionCountsCache = impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInRedis_1.ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
-        var uniqueKeysCache = impressionsMode === constants_1.NONE ? new uniqueKeysCacheInRedis_1.UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
-            if (impressionCountsCache)
-                impressionCountsCache.start();
-            if (uniqueKeysCache)
-                uniqueKeysCache.start();
             // Synchronize config
             telemetry.recordConfig();
         });
@@ -40,19 +32,12 @@ function InRedisStorage(options) {
             splits: new SplitsCacheInRedis_1.SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis_1.SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis_1.ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
-            impressionCounts: impressionCountsCache,
             events: new EventsCacheInRedis_1.EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
             telemetry: telemetry,
-            uniqueKeys: uniqueKeysCache,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                var promises = [];
-                if (impressionCountsCache)
-                    promises.push(impressionCountsCache.stop());
-                if (uniqueKeysCache)
-                    promises.push(uniqueKeysCache.stop());
-                return Promise.all(promises).then(function () { redisClient.disconnect(); });
+                redisClient.disconnect();
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCachePluggable = void 0;
+var KeyBuilderSS_1 = require("../KeyBuilderSS");
 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 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, KeyBuilderSS_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, KeyBuilderSS_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, KeyBuilderSS_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/index.js

@@ -14,6 +14,8 @@ 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 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 +32,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 +47,39 @@ 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 log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, optimize = params.optimize;
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
         var isPartialConsumer = mode === constants_1.CONSUMER_PARTIAL_MODE;
+        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ?
+            isPartialConsumer ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
-        wrapperConnect(wrapper, onReadyCb);
+        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();
+        }).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,
             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),
+            telemetry: telemetry,
             // Disconnect the underlying storage
             destroy: 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/sync/submitters/submitterManager.js

@@ -5,7 +5,6 @@ var eventsSubmitter_1 = require("./eventsSubmitter");
 var impressionsSubmitter_1 = require("./impressionsSubmitter");
 var impressionCountsSubmitter_1 = require("./impressionCountsSubmitter");
 var telemetrySubmitter_1 = require("./telemetrySubmitter");
-var uniqueKeysSubmitter_1 = require("./uniqueKeysSubmitter");
 function submitterManagerFactory(params) {
     var submitters = [
         (0, impressionsSubmitter_1.impressionsSubmitterFactory)(params),
@@ -15,8 +14,6 @@ function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
-    if (params.uniqueKeysTracker)
-        submitters.push((0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
         start: function (onlyTelemetry) {

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -9,6 +9,7 @@ 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");
+var utils_1 = require("../../trackers/impressionObserver/utils");
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -29,9 +30,9 @@ function telemetryCacheStatsAdapter(telemetry, splits, segments) {
                 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(),
+                spC: splits && splits.getSplitNames().length,
+                seC: segments && segments.getRegisteredSegments().length,
+                skC: segments && segments.getKeysCount(),
                 sL: telemetry.getSessionLength(),
                 eQ: telemetry.getEventStats(constants_1.QUEUED),
                 eD: telemetry.getEventStats(constants_1.DROPPED),
@@ -50,7 +51,6 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[constants_1.OPTIMIZED] = constants_1.OPTIMIZED_ENUM,
     _b[constants_1.DEBUG] = constants_1.DEBUG_ENUM,
-    _b[constants_1.NONE] = constants_1.NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[constants_1.CONSENT_UNKNOWN] = 1,
@@ -126,7 +126,9 @@ function telemetrySubmitterFactory(params) {
         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 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, 
+    // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
+    (0, utils_1.isStorageSync)(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/cjs/trackers/impressionsTracker.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.impressionsTrackerFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var thenable_1 = require("../utils/promise/thenable");
+var time_1 = require("../utils/time");
 var constants_1 = require("../logger/constants");
 var constants_2 = require("../utils/constants");
 /**
@@ -12,34 +13,52 @@ var constants_2 = require("../utils/constants");
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
+ * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
+// if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
+observer, 
+// if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
+countsCache, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === constants_2.CONSENT_DECLINED)
                 return;
             var impressionsCount = impressions.length;
-            var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
-            var impressionsToListenerCount = impressionsToListener.length;
-            if (impressionsToStore.length > 0) {
-                var res = impressionsCache.track(impressionsToStore);
-                // If we're on an async storage, handle error and log it.
-                if ((0, thenable_1.thenable)(res)) {
-                    res.then(function () {
-                        log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                    }).catch(function (err) {
-                        log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                    });
+            var impressionsToStore = []; // Track only the impressions that are going to be stored
+            // Wraps impressions to store and adds previousTime if it corresponds
+            impressions.forEach(function (impression) {
+                if (observer) {
+                    // Adds previous time if it is enabled
+                    impression.pt = observer.testAndSet(impression);
                 }
-                else {
-                    // Record when impressionsCache is sync only (standalone mode)
-                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                    if (telemetryCache) {
-                        telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
-                        telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
-                    }
+                var now = Date.now();
+                if (countsCache) {
+                    // Increments impression counter per featureName
+                    countsCache.track(impression.feature, now, 1);
+                }
+                // Checks if the impression should be added in queue to be sent
+                if (!countsCache || !impression.pt || impression.pt < (0, time_1.truncateTimeFrame)(now)) {
+                    impressionsToStore.push(impression);
+                }
+            });
+            var res = impressionsCache.track(impressionsToStore);
+            // If we're on an async storage, handle error and log it.
+            if ((0, thenable_1.thenable)(res)) {
+                res.then(function () {
+                    log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                }).catch(function (err) {
+                    log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                });
+            }
+            else {
+                // Record when impressionsCache is sync only (standalone mode)
+                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                if (telemetryCache) {
+                    telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
+                    telemetryCache.recordImpressionStats(constants_2.DEDUPED, impressions.length - impressionsToStore.length);
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
@@ -47,7 +66,7 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: (0, objectAssign_1.objectAssign)({}, impressionsToListener[i]),
+                        impression: (0, objectAssign_1.objectAssign)({}, impressions[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -67,7 +86,7 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsToListenerCount; i++) {
+                for (var i = 0; i < impressionsCount; i++) {
                     _loop_1(i);
                 }
             }

package/cjs/utils/constants/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABLY_ERROR = exports.TOKEN_REFRESH = exports.SSE_CONNECTION_ERROR = exports.STREAMING_STATUS = exports.OCCUPANCY_SEC = exports.OCCUPANCY_PRI = exports.CONNECTION_ESTABLISHED = exports.TRACK = exports.TREATMENTS_WITH_CONFIG = exports.TREATMENT_WITH_CONFIG = exports.TREATMENTS = exports.TREATMENT = exports.MY_SEGMENT = exports.SEGMENT = exports.TOKEN = exports.TELEMETRY = exports.EVENTS = exports.IMPRESSIONS_COUNT = exports.IMPRESSIONS = exports.SPLITS = exports.NONE_ENUM = exports.DEBUG_ENUM = exports.OPTIMIZED_ENUM = exports.CONSUMER_PARTIAL_ENUM = exports.CONSUMER_ENUM = exports.STANDALONE_ENUM = exports.DEDUPED = exports.DROPPED = exports.QUEUED = exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.NONE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
-exports.PAUSED = exports.ENABLED = exports.DISABLED = exports.NON_REQUESTED = exports.REQUESTED = exports.POLLING = exports.STREAMING = exports.AUTH_REJECTION = exports.SYNC_MODE_UPDATE = void 0;
+exports.AUTH_REJECTION = exports.SYNC_MODE_UPDATE = exports.ABLY_ERROR = exports.TOKEN_REFRESH = exports.SSE_CONNECTION_ERROR = exports.STREAMING_STATUS = exports.OCCUPANCY_SEC = exports.OCCUPANCY_PRI = exports.CONNECTION_ESTABLISHED = exports.TRACK = exports.TREATMENTS_WITH_CONFIG = exports.TREATMENT_WITH_CONFIG = exports.TREATMENTS = exports.TREATMENT = exports.MY_SEGMENT = exports.SEGMENT = exports.TOKEN = exports.TELEMETRY = exports.EVENTS = exports.IMPRESSIONS_COUNT = exports.IMPRESSIONS = exports.SPLITS = exports.DEBUG_ENUM = exports.OPTIMIZED_ENUM = exports.CONSUMER_PARTIAL_ENUM = exports.CONSUMER_ENUM = exports.STANDALONE_ENUM = exports.DEDUPED = exports.DROPPED = exports.QUEUED = exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
+exports.PAUSED = exports.ENABLED = exports.DISABLED = exports.NON_REQUESTED = exports.REQUESTED = exports.POLLING = exports.STREAMING = void 0;
 // Special treatments
 exports.CONTROL = 'control';
 exports.CONTROL_WITH_CONFIG = {
@@ -17,7 +17,6 @@ exports.SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 exports.DEBUG = 'DEBUG';
 exports.OPTIMIZED = 'OPTIMIZED';
-exports.NONE = 'NONE';
 // SDK Modes
 exports.LOCALHOST_MODE = 'localhost';
 exports.STANDALONE_MODE = 'standalone';
@@ -42,7 +41,6 @@ exports.CONSUMER_ENUM = 1;
 exports.CONSUMER_PARTIAL_ENUM = 2;
 exports.OPTIMIZED_ENUM = 0;
 exports.DEBUG_ENUM = 1;
-exports.NONE_ENUM = 2;
 exports.SPLITS = 'sp';
 exports.IMPRESSIONS = 'im';
 exports.IMPRESSIONS_COUNT = 'ic';

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/settingsValidation/impressionsMode.js

@@ -6,9 +6,9 @@ var constants_2 = require("../constants");
 var lang_1 = require("../lang");
 function validImpressionsMode(log, impressionsMode) {
     impressionsMode = (0, lang_1.stringToUpperCase)(impressionsMode);
-    if ([constants_2.DEBUG, constants_2.OPTIMIZED, constants_2.NONE].indexOf(impressionsMode) > -1)
+    if ([constants_2.DEBUG, constants_2.OPTIMIZED].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(constants_1.ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [constants_2.DEBUG, constants_2.OPTIMIZED, constants_2.NONE], constants_2.OPTIMIZED]);
+    log.error(constants_1.ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [constants_2.DEBUG, constants_2.OPTIMIZED], constants_2.OPTIMIZED]);
     return constants_2.OPTIMIZED;
 }
 exports.validImpressionsMode = validImpressionsMode;

package/cjs/utils/settingsValidation/index.js

@@ -34,8 +34,6 @@ exports.base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -114,7 +112,6 @@ function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if ((0, lang_1.get)(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === constants_1.DEBUG)

package/esm/consent/sdkUserConsent.js

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

package/esm/evaluator/index.js

@@ -15,21 +15,21 @@ function treatmentsException(splitNames) {
     return evaluations;
 }
 export function evaluateFeature(log, key, splitName, attributes, storage) {
-    var stringifiedSplit;
+    var parsedSplit;
     try {
-        stringifiedSplit = storage.splits.getSplit(splitName);
+        parsedSplit = storage.splits.getSplit(splitName);
     }
     catch (e) {
         // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
         return treatmentException;
     }
-    if (thenable(stringifiedSplit)) {
-        return stringifiedSplit.then(function (result) { return getEvaluation(log, result, key, attributes, storage); }).catch(
+    if (thenable(parsedSplit)) {
+        return parsedSplit.then(function (split) { return getEvaluation(log, split, key, attributes, storage); }).catch(
         // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         function () { return treatmentException; });
     }
-    return getEvaluation(log, stringifiedSplit, key, attributes, storage);
+    return getEvaluation(log, parsedSplit, key, attributes, storage);
 }
 export function evaluateFeatures(log, key, splitNames, attributes, storage) {
     var parsedSplits;

package/esm/listeners/browser.js

@@ -1,6 +1,6 @@
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
-import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
@@ -71,10 +71,9 @@ var BrowserSignalListener = /** @class */ (function () {
         // Flush impressions & events data if there is user consent
         if (isConsentGranted(this.settings)) {
             var eventsUrl = this.settings.urls.events;
-            var sim = this.settings.sync.impressionsMode;
             var extraMetadata = {
                 // sim stands for Sync/Split Impressions Mode
-                sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
+                sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
             };
             this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
             this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);

package/esm/logger/constants.js

@@ -139,5 +139,4 @@ export var LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
 export var LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export var LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export var LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
-export var LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';
 export var LOG_PREFIX_CLEANUP = 'cleanup: ';