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

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -31,15 +32,12 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
-            if (split) {
-                var parsedSplit = JSON.parse(split);
-                if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                    parsedSplit.killed = true;
-                    parsedSplit.defaultTreatment = defaultTreatment;
-                    parsedSplit.changeNumber = changeNumber;
-                    var newSplit = JSON.stringify(parsedSplit);
-                    return _this.addSplit(name, newSplit);
-                }
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = objectAssign({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(name, newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,3 +1,4 @@
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -44,15 +45,12 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      */
     AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
         var split = this.getSplit(name);
-        if (split) {
-            var parsedSplit = JSON.parse(split);
-            if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-                parsedSplit.killed = true;
-                parsedSplit.defaultTreatment = defaultTreatment;
-                parsedSplit.changeNumber = changeNumber;
-                var newSplit = JSON.stringify(parsedSplit);
-                return this.addSplit(name, newSplit);
-            }
+        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+            var newSplit = objectAssign({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(name, newSplit);
         }
         return false;
     };

package/esm/storages/KeyBuilderSS.js

@@ -20,12 +20,6 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
-    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
-        return this.prefix + ".impressions.count";
-    };
-    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
-        return this.prefix + ".uniquekeys";
-    };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };

package/esm/storages/dataLoader.js

@@ -32,7 +32,7 @@ export function dataLoaderFactory(preloadedData) {
         storage.splits.clear();
         storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return [splitName, splitsData[splitName]]; }));
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
         // add mySegments data
         var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -93,9 +93,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             this._decrementCounts(previousSplit);
-            localStorage.setItem(splitKey, split);
-            var parsedSplit = split ? JSON.parse(split) : null;
-            this._incrementCounts(parsedSplit);
+            localStorage.setItem(splitKey, JSON.stringify(split));
+            this._incrementCounts(split);
             return true;
         }
         catch (e) {
@@ -107,8 +106,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         try {
             var split = this.getSplit(name);
             localStorage.removeItem(this.keys.buildSplitKey(name));
-            var parsedSplit = JSON.parse(split);
-            this._decrementCounts(parsedSplit);
+            this._decrementCounts(split);
             return true;
         }
         catch (e) {
@@ -117,7 +115,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
-        return localStorage.getItem(this.keys.buildSplitKey(name));
+        var item = localStorage.getItem(this.keys.buildSplitKey(name));
+        return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when cache is ready but using a new split query, we must clear all split data

package/esm/storages/inLocalStorage/index.js

@@ -11,9 +11,8 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -36,15 +35,12 @@ export function InLocalStorage(options) {
             impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(params.eventsQueueSize),
             telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-            uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
-                var _a;
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
-                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -1,11 +1,7 @@
 import { truncateTimeFrame } from '../../utils/time';
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
-        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = DEFAULT_CACHE_SIZE; }
+    function ImpressionCountsCacheInMemory() {
         this.cache = {};
-        this.cacheSize = 0;
-        this.maxStorage = impressionCountsCacheSize;
     }
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -20,13 +16,6 @@ var ImpressionCountsCacheInMemory = /** @class */ (function () {
         var key = this._makeKey(featureName, timeFrame);
         var currentAmount = this.cache[key];
         this.cache[key] = currentAmount ? currentAmount + amount : amount;
-        if (this.onFullQueue) {
-            this.cacheSize = this.cacheSize + amount;
-            if (this.cacheSize >= this.maxStorage) {
-                this.onFullQueue();
-                this.cacheSize = 0;
-            }
-        }
     };
     /**
      * Pop the collected data, used as payload for posting.

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,9 +3,8 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './uniqueKeysCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -16,19 +15,16 @@ export function InMemoryStorageFactory(params) {
         splits: new SplitsCacheInMemory(),
         segments: new SegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
         telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
-            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
-            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         }
     };
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

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

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -22,9 +22,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
-        var splitFromMemory = this.getSplit(name);
-        if (splitFromMemory) { // We had this Split already
-            var previousSplit = JSON.parse(splitFromMemory);
+        var previousSplit = this.getSplit(name);
+        if (previousSplit) { // We had this Split already
             if (previousSplit.trafficTypeName) {
                 var previousTtName = previousSplit.trafficTypeName;
                 this.ttCache[previousTtName]--;
@@ -35,19 +34,18 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 this.splitsWithSegmentsCount--;
             }
         }
-        var parsedSplit = JSON.parse(split);
-        if (parsedSplit) {
+        if (split) {
             // Store the Split.
             this.splitsCache[name] = split;
             // Update TT cache
-            var ttName = parsedSplit.trafficTypeName;
+            var ttName = split.trafficTypeName;
             if (ttName) { // safeguard
                 if (!this.ttCache[ttName])
                     this.ttCache[ttName] = 0;
                 this.ttCache[ttName]++;
             }
             // Add to segments count for the new version of the Split
-            if (usesSegments(parsedSplit))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount++;
             return true;
         }
@@ -60,15 +58,14 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         if (split) {
             // Delete the Split
             delete this.splitsCache[name];
-            var parsedSplit = JSON.parse(split);
-            var ttName = parsedSplit.trafficTypeName;
+            var ttName = split.trafficTypeName;
             if (ttName) { // safeguard
                 this.ttCache[ttName]--; // Update tt cache
                 if (!this.ttCache[ttName])
                     delete this.ttCache[ttName];
             }
             // Update the segments count.
-            if (usesSegments(parsedSplit))
+            if (usesSegments(split))
                 this.splitsWithSegmentsCount--;
             return true;
         }

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -59,17 +59,17 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing errors
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, newStringifiedSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                newStringifiedSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.redis.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.redis.set(splitKey, newStringifiedSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -96,8 +96,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.redis.del(_this.keys.buildSplitKey(name));
         });
@@ -120,7 +119,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             this.log.error(LOG_PREFIX + this.redisError);
             return Promise.reject(this.redisError);
         }
-        return this.redis.get(this.keys.buildSplitKey(name));
+        return this.redis.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Set till number.
@@ -155,7 +155,12 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      */
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); }).then(processPipelineAnswer);
+        return this.redis.keys(this.keys.searchPatternForSplitKeys())
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(processPipelineAnswer)
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.
@@ -215,7 +220,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
         return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         })

package/esm/storages/inRedis/constants.js

@@ -1,4 +1 @@
 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,10 +5,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
+import { 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}
@@ -17,19 +15,13 @@ 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, impressionsMode = _a.impressionsMode;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
         var keys = new KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-        var impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
-        var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
-            if (impressionCountsCache)
-                impressionCountsCache.start();
-            if (uniqueKeysCache)
-                uniqueKeysCache.start();
             // Synchronize config
             telemetry.recordConfig();
         });
@@ -37,18 +29,12 @@ 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/pluggable/SplitsCachePluggable.js

@@ -46,17 +46,17 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                stringifiedNewSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.wrapper.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.wrapper.set(splitKey, stringifiedNewSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type and segment count of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -80,8 +80,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
@@ -101,7 +100,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * or rejected if wrapper operation fails.
      */
     SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name));
+        return this.wrapper.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Get list of splits.
@@ -114,7 +114,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getMany(keys).then(function (splitDefinitions) {
             var splits = {};
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         });
@@ -126,7 +127,11 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      */
     SplitsCachePluggable.prototype.getAll = function () {
         var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return Promise.all(listOfKeys.map(_this.wrapper.get)); });
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -24,8 +24,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
             log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             forOwn(splitsMock, function (val, name) {
                 splits.push([
-                    name,
-                    JSON.stringify({
+                    name, {
                         name: name,
                         status: 'ACTIVE',
                         killed: false,
@@ -34,7 +33,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                         conditions: val.conditions || [],
                         configurations: val.configurations,
                         trafficTypeName: val.trafficTypeName
-                    })
+                    }
                 ]);
             });
             return Promise.all([

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -37,7 +37,7 @@ export function computeSplitsMutation(entries) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE') {
-            accum.added.push([split.name, JSON.stringify(split)]);
+            accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });

package/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,6 @@ 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),
@@ -12,8 +11,6 @@ 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, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_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, DEBUG_ENUM, OPTIMIZED_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,7 +46,6 @@ 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/trackers/impressionsTracker.js

@@ -1,5 +1,6 @@
 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';
 /**
@@ -9,34 +10,52 @@ 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 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)
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+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) {
     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 _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 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(QUEUED, impressionsToStore.length);
-                        telemetryCache.recordImpressionStats(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 < 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);
                 }
             }
             // @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
@@ -44,7 +63,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressionsToListener[i]),
+                        impression: objectAssign({}, impressions[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -64,7 +83,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsToListenerCount; i++) {
+                for (var i = 0; i < impressionsCount; i++) {
                     _loop_1(i);
                 }
             }