@splitsoftware/splitio-commons 1.6.2-rc.6 → 1.6.2-rc.7

package/esm/storages/inMemory/uniqueKeysCacheInMemory.js

@@ -0,0 +1,70 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+var UniqueKeysCacheInMemory = /** @class */ (function () {
+    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = feature name.
+     * value: Set<string> = set of unique keys.
+     */
+    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[featureName])
+            this.uniqueKeysTracker[featureName] = new _Set();
+        var tracker = this.uniqueKeysTracker[featureName];
+        if (!tracker.has(key)) {
+            tracker.add(key);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemory.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemory.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload for SS.
+     */
+    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var featureNames = Object.keys(uniqueKeys);
+        for (var i = 0; i < featureNames.length; i++) {
+            var featureName = featureNames[i];
+            var featureKeys = setToArray(uniqueKeys[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemory;
+}());
+export { UniqueKeysCacheInMemory };

package/esm/storages/inMemory/uniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,75 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = key.
+     * value: HashSet<string> = set of split names.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[key])
+            this.uniqueKeysTracker[key] = new _Set();
+        var tracker = this.uniqueKeysTracker[key];
+        if (!tracker.has(featureName)) {
+            tracker.add(featureName);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var featureKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < featureKeys.length; k++) {
+            var featureKey = featureKeys[k];
+            var featureNames = setToArray(uniqueKeys[featureKey]);
+            var uniqueKeysPayload = {
+                k: featureKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+export { UniqueKeysCacheInMemoryCS };

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -0,0 +1,46 @@
+import { __extends } from "tslib";
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
+    __extends(ImpressionCountsCacheInRedis, _super);
+    function ImpressionCountsCacheInRedis(log, key, redis, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.redis = redis;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.postImpressionCountsInRedis(); };
+        return _this;
+    }
+    ImpressionCountsCacheInRedis.prototype.postImpressionCountsInRedis = function () {
+        var _this = this;
+        var counts = this.pop();
+        if (!counts)
+            return false;
+        var keys = Object.keys(counts);
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        return pipeline.exec()
+            .then(function (data) {
+            // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+            if (data.length && data.length === keys.length) {
+                return _this.redis.expire(_this.key, TTL_REFRESH);
+            }
+        })
+            .catch(function (err) {
+            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCacheInRedis.prototype.start = function () {
+        this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCacheInRedis.prototype.stop = function () {
+        clearInterval(this.intervalId);
+    };
+    return ImpressionCountsCacheInRedis;
+}(ImpressionCountsCacheInMemory));
+export { ImpressionCountsCacheInRedis };

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,10 @@ 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';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -15,13 +17,19 @@ 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;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode, impressionCountsQueueSize = _a.impressionCountsQueueSize, impressionCountsRefreshRate = _a.impressionCountsRefreshRate, uniqueKeysCacheSize = _a.uniqueKeysCacheSize, uniqueKeysRefreshRate = _a.uniqueKeysRefreshRate;
         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, impressionCountsQueueSize, impressionCountsRefreshRate) : undefined;
+        var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient, uniqueKeysCacheSize, uniqueKeysRefreshRate) : 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 +37,18 @@ 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();
+                if (impressionCountsCache)
+                    impressionCountsCache.stop();
+                if (uniqueKeysCache)
+                    uniqueKeysCache.stop();
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/esm/storages/inRedis/uniqueKeysCacheInRedis.js

@@ -0,0 +1,53 @@
+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 pipeline = this.redis.pipeline();
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        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 UniqueKeysCacheInRedis;
+}(UniqueKeysCacheInMemory));
+export { UniqueKeysCacheInRedis };

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.uniqueKeysTracker)
+        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,6 +1,6 @@
 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 { QUEUED, DEDUPED, DROPPED, 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';
@@ -46,6 +46,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,

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -0,0 +1,22 @@
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { submitterFactory } from './submitter';
+var DATA_NAME = 'uniqueKeys';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export 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 isClientSide = key !== undefined;
+    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys');
+    // 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/impressionsTracker.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 /**
@@ -10,52 +9,34 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @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)
+ * @param strategy strategy for impressions tracking.
  */
-export 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) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, 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 === CONSENT_DECLINED)
                 return;
             var impressionsCount = impressions.length;
-            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);
+            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 (thenable(res)) {
+                    res.then(function () {
+                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                    }).catch(function (err) {
+                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                    });
                 }
-                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 < truncateTimeFrame(now)) {
-                    impressionsToStore.push(impression);
-                }
-            });
-            var res = impressionsCache.track(impressionsToStore);
-            // If we're on an async storage, handle error and log it.
-            if (thenable(res)) {
-                res.then(function () {
-                    log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                }).catch(function (err) {
-                    log.error(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(QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
+                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(QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(DEDUPED, deduped);
+                    }
                 }
             }
             // @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
@@ -63,7 +44,7 @@ countsCache, telemetryCache) {
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressions[i]),
+                        impression: objectAssign({}, impressionsToListener[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -83,7 +64,7 @@ countsCache, telemetryCache) {
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsCount; i++) {
+                for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);
                 }
             }

package/esm/trackers/strategy/strategyDebug.js

@@ -0,0 +1,21 @@
+/**
+ * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
+ * @returns IStrategyResult
+ */
+export function strategyDebugFactory(impressionsObserver) {
+    return {
+        process: function (impressions) {
+            impressions.forEach(function (impression) {
+                // Adds previous time if it is enabled
+                impression.pt = impressionsObserver.testAndSet(impression);
+            });
+            return {
+                impressionsToStore: impressions,
+                impressionsToListener: impressions,
+                deduped: 0
+            };
+        }
+    };
+}

package/esm/trackers/strategy/strategyNone.js

@@ -0,0 +1,25 @@
+/**
+ * None strategy for impressions tracker.
+ *
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
+ * @returns IStrategyResult
+ */
+export function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
+    return {
+        process: function (impressions) {
+            impressions.forEach(function (impression) {
+                var now = Date.now();
+                // Increments impression counter per featureName
+                impressionsCounter.track(impression.feature, now, 1);
+                // Keep track by unique key
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
+            });
+            return {
+                impressionsToStore: [],
+                impressionsToListener: impressions,
+                deduped: 0
+            };
+        }
+    };
+}

package/esm/trackers/strategy/strategyOptimized.js

@@ -0,0 +1,31 @@
+import { truncateTimeFrame } from '../../utils/time';
+/**
+ * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @returns IStrategyResult
+ */
+export function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {
+    return {
+        process: function (impressions) {
+            var impressionsToStore = [];
+            impressions.forEach(function (impression) {
+                impression.pt = impressionsObserver.testAndSet(impression);
+                var now = Date.now();
+                // Increments impression counter per featureName
+                if (impression.pt)
+                    impressionsCounter.track(impression.feature, now, 1);
+                // Checks if the impression should be added in queue to be sent
+                if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
+                    impressionsToStore.push(impression);
+                }
+            });
+            return {
+                impressionsToStore: impressionsToStore,
+                impressionsToListener: impressions,
+                deduped: impressions.length - impressionsToStore.length
+            };
+        }
+    };
+}

package/esm/trackers/uniqueKeysTracker.js

@@ -0,0 +1,34 @@
+import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
+var noopFilterAdapter = {
+    add: function () { return true; },
+    contains: function () { return true; },
+    clear: function () { }
+};
+/**
+ * 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.
+ *
+ * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
+ */
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
+    if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
+    return {
+        track: function (key, featureName) {
+            if (!filterAdapter.add(key, featureName)) {
+                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
+                return;
+            }
+            uniqueKeysCache.track(key, featureName);
+        },
+        stop: function () {
+            clearInterval(intervalId);
+        }
+    };
+}

package/esm/utils/constants/index.js

@@ -13,6 +13,7 @@ export var SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export var DEBUG = 'DEBUG';
 export var OPTIMIZED = 'OPTIMIZED';
+export var NONE = 'NONE';
 // SDK Modes
 export var LOCALHOST_MODE = 'localhost';
 export var STANDALONE_MODE = 'standalone';
@@ -37,6 +38,7 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
+export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { DEBUG, OPTIMIZED } from '../constants';
+import { DEBUG, OPTIMIZED, NONE } from '../constants';
 import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
     impressionsMode = stringToUpperCase(impressionsMode);
-    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
+    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
     return OPTIMIZED;
 }

package/esm/utils/settingsValidation/index.js

@@ -31,6 +31,8 @@ export var 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
@@ -109,6 +111,8 @@ export 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.impressionCountsRefreshRate = fromSecondsToMillis(scheduler.impressionCountsRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)

package/package.json

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

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);