@splitsoftware/splitio-commons 2.0.3-rc.0 → 2.1.0-rc.1

package/cjs/storages/inRedis/index.js

@@ -23,18 +23,20 @@ function InRedisStorage(options) {
     var RD = require('./RedisAdapter').RedisAdapter;
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     function InRedisStorageFactory(params) {
-        var onReadyCb = params.onReadyCb, settings = params.settings, log = params.settings.log;
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
         var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var redisClient = new RD(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
-        var impressionCountsCache = new ImpressionCountsCacheInRedis_1.ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient);
-        var uniqueKeysCache = new UniqueKeysCacheInRedis_1.UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), 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();
-            impressionCountsCache.start();
-            uniqueKeysCache.start();
+            if (impressionCountsCache)
+                impressionCountsCache.start();
+            if (uniqueKeysCache)
+                uniqueKeysCache.start();
             // Synchronize config
             telemetry.recordConfig();
         });
@@ -49,10 +51,12 @@ function InRedisStorage(options) {
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                return Promise.all([
-                    impressionCountsCache.stop(),
-                    uniqueKeysCache.stop()
-                ]).then(function () { redisClient.disconnect(); });
+                var promises = [];
+                if (impressionCountsCache)
+                    promises.push(impressionCountsCache.stop());
+                if (uniqueKeysCache)
+                    promises.push(uniqueKeysCache.stop());
+                return Promise.all(promises).then(function () { redisClient.disconnect(); });
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };

package/cjs/storages/pluggable/index.js

@@ -54,27 +54,32 @@ function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     function PluggableStorageFactory(params) {
-        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, mode = _a.mode, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, mode = _a.mode, impressionsMode = _a.sync.impressionsMode, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
         var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
-        var isSynchronizer = mode === undefined; // If mode is not defined, the synchronizer is running
+        var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === constants_1.CONSUMER_PARTIAL_MODE;
-        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) || isSynchronizer ?
+        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) || isSyncronizer ?
             isPartialConsumer ?
                 new TelemetryCacheInMemory_1.TelemetryCacheInMemory() :
                 new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
             undefined;
-        var impressionCountsCache = isPartialConsumer ?
-            new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() :
-            new ImpressionCountsCachePluggable_1.ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper);
-        var uniqueKeysCache = isPartialConsumer ?
-            settings.core.key === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
-            new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper);
+        var impressionCountsCache = impressionsMode !== constants_1.DEBUG || isSyncronizer ?
+            isPartialConsumer ?
+                new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() :
+                new ImpressionCountsCachePluggable_1.ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+            undefined;
+        var uniqueKeysCache = impressionsMode === constants_1.NONE || isSyncronizer ?
+            isPartialConsumer ?
+                settings.core.key === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
+                new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
-            if (isSynchronizer) {
-                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+            if (isSyncronizer) {
+                // @TODO reuse InLocalStorage::validateCache logic
+                // In standalone or producer mode, clear storage if SDK key, flags filter criteria or flags spec version was modified
                 return wrapper.get(keys.buildHashKey()).then(function (hash) {
                     var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
                     if (hash !== currentHash) {
@@ -89,9 +94,9 @@ function PluggableStorage(options) {
             }
             else {
                 // Start periodic flush of async storages if not running synchronizer (producer mode)
-                if (impressionCountsCache.start)
+                if (impressionCountsCache && impressionCountsCache.start)
                     impressionCountsCache.start();
-                if (uniqueKeysCache.start)
+                if (uniqueKeysCache && uniqueKeysCache.start)
                     uniqueKeysCache.start();
                 if (telemetry && telemetry.recordConfig)
                     telemetry.recordConfig();
@@ -112,9 +117,9 @@ function PluggableStorage(options) {
             uniqueKeys: uniqueKeysCache,
             // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
-                return Promise.all(isSynchronizer ? [] : [
-                    impressionCountsCache.stop && impressionCountsCache.stop(),
-                    uniqueKeysCache.stop && uniqueKeysCache.stop(),
+                return Promise.all(isSyncronizer ? [] : [
+                    impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
+                    uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
                 ]).then(function () { return wrapper.disconnect(); });
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage

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

@@ -46,9 +46,10 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                    var isCacheLoaded_1 = storage.validateCache ? storage.validateCache() : false;
+                    Promise.resolve().then(function () {
                         // Emits SDK_READY_FROM_CACHE
-                        if (cacheReady)
+                        if (isCacheLoaded_1)
                             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);

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

@@ -126,7 +126,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(constants_2.SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+            return Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -170,15 +170,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 }
                 return false;
             });
-            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
-            // Wrapping in a promise since checkCache can be async.
-            if (splitsEventEmitter && startingUp) {
-                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
-                    if (isCacheReady)
-                        splitsEventEmitter.emit(constants_1.SDK_SPLITS_CACHE_LOADED);
-                });
-            }
-            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/cjs/sync/streaming/pushManager.js

@@ -309,12 +309,14 @@ function pushManagerFactory(params, pollingManager) {
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls
                 // in case multiple clients are created in the current cycle.
-                setTimeout(function checkForReconnect() {
-                    if (connectForNewClient) {
-                        connectForNewClient = false;
-                        connectPush();
-                    }
-                }, 0);
+                if (this.isRunning()) {
+                    setTimeout(function checkForReconnect() {
+                        if (connectForNewClient) {
+                            connectForNewClient = false;
+                            connectPush();
+                        }
+                    }, 0);
+                }
             }
         },
         // [Only for client-side]

package/cjs/sync/submitters/impressionCountsSubmitter.js

@@ -30,7 +30,9 @@ var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
  */
 function impressionCountsSubmitterFactory(params) {
     var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
-    // retry impressions counts only once.
-    return (0, submitter_1.submitterFactory)(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);
+    if (impressionCounts) {
+        // retry impressions counts only once.
+        return (0, submitter_1.submitterFactory)(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);
+    }
 }
 exports.impressionCountsSubmitterFactory = impressionCountsSubmitterFactory;

package/cjs/sync/submitters/submitterManager.js

@@ -9,11 +9,14 @@ var uniqueKeysSubmitter_1 = require("./uniqueKeysSubmitter");
 function submitterManagerFactory(params) {
     var submitters = [
         (0, impressionsSubmitter_1.impressionsSubmitterFactory)(params),
-        (0, eventsSubmitter_1.eventsSubmitterFactory)(params),
-        (0, impressionCountsSubmitter_1.impressionCountsSubmitterFactory)(params),
-        (0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params)
+        (0, eventsSubmitter_1.eventsSubmitterFactory)(params)
     ];
+    var impressionCountsSubmitter = (0, impressionCountsSubmitter_1.impressionCountsSubmitterFactory)(params);
+    if (impressionCountsSubmitter)
+        submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
+    if (params.storage.uniqueKeys)
+        submitters.push((0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
         start: function (onlyTelemetry) {

package/cjs/sync/syncManagerOnline.js

@@ -6,6 +6,7 @@ var constants_1 = require("./streaming/constants");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
+var constants_4 = require("../readiness/constants");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -19,7 +20,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
         var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
@@ -67,6 +68,11 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
              */
             start: function () {
                 running = true;
+                if (startFirstTime) {
+                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+                    if (isCacheLoaded)
+                        Promise.resolve().then(function () { readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED); });
+                }
                 // start syncing splits and segments
                 if (pollingManager) {
                     // If synchronization is disabled pushManager and pollingManager should not start
@@ -75,7 +81,6 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                             // Doesn't call `syncAll` when the syncManager is resuming
                             if (startFirstTime) {
                                 pollingManager.syncAll();
-                                startFirstTime = false;
                             }
                             pushManager.start();
                         }
@@ -86,12 +91,12 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                     else {
                         if (startFirstTime) {
                             pollingManager.syncAll();
-                            startFirstTime = false;
                         }
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
                 submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
+                startFirstTime = false;
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -118,6 +123,8 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
+                if (syncEnabled && pushManager)
+                    pushManager.add(matchingKey, mySegmentsSyncTask);
                 if (running) {
                     if (syncEnabled) {
                         if (pushManager) {
@@ -131,7 +138,6 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                                 // of segments since `syncAll` was already executed when starting the main client
                                 mySegmentsSyncTask.execute();
                             }
-                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
                             if (storage.splits.usesSegments())

package/cjs/trackers/eventTracker.js

@@ -25,7 +25,7 @@ function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManage
                 whenInit(function () {
                     // Wrap in a timeout because we don't want it to be blocking.
                     setTimeout(function () {
-                        // copy of event, to avoid unexpected behaviour if modified by integrations
+                        // copy of event, to avoid unexpected behavior if modified by integrations
                         var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
                         if (properties)
                             eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);

package/cjs/trackers/impressionsTracker.js

@@ -7,37 +7,38 @@ var constants_1 = require("../logger/constants");
 var constants_2 = require("../utils/constants");
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
+ *
+ * @param impressionsCache - cache to save impressions
+ * @param metadata - runtime metadata (ip, hostname and version)
+ * @param impressionListener - optional impression listener
+ * @param integrationsManager - optional integrations manager
+ * @param strategy - strategy for impressions tracking.
  */
-function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
+function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, 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 === constants_2.CONSENT_DECLINED)
                 return;
-            var impressionsToStore = impressions.filter(function (_a) {
-                var impression = _a[0], track = _a[1];
-                return track === false ?
-                    noneStrategy.process(impression) :
-                    strategy.process(impression);
-            });
-            var impressionsLength = impressions.length;
-            var impressionsToStoreLength = impressionsToStore.length;
-            if (impressionsToStoreLength) {
-                var res = impressionsCache.track(impressionsToStore.map(function (item) { return item[0]; }));
+            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, [impressionsLength]);
+                        log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
                     }).catch(function (err) {
-                        log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsLength, 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, impressionsToStoreLength);
-                        telemetryCache.recordImpressionStats(constants_2.DEDUPED, impressionsLength - impressionsToStoreLength);
+                        telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
                     }
                 }
             }
@@ -45,8 +46,8 @@ function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, str
             if (impressionListener || integrationsManager) {
                 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)({}, impressions[i][0]),
+                        // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
+                        impression: (0, objectAssign_1.objectAssign)({}, impressionsToListener[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -68,7 +69,7 @@ function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, str
                         });
                     });
                 };
-                for (var i = 0; i < impressionsLength; i++) {
+                for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);
                 }
             }

package/cjs/trackers/strategy/strategyDebug.js

@@ -5,13 +5,20 @@ exports.strategyDebugFactory = void 0;
  * 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 Debug strategy
+ * @returns IStrategyResult
  */
 function strategyDebugFactory(impressionsObserver) {
     return {
-        process: function (impression) {
-            impression.pt = impressionsObserver.testAndSet(impression);
-            return true;
+        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/cjs/trackers/strategy/strategyNone.js

@@ -4,20 +4,25 @@ exports.strategyNoneFactory = void 0;
 /**
  * None strategy for impressions tracker.
  *
- * @param impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @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 None strategy
+ * @returns IStrategyResult
  */
-function strategyNoneFactory(impressionCounts, uniqueKeysTracker) {
+function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
     return {
-        process: function (impression) {
-            var now = Date.now();
-            // Increments impression counter per featureName
-            impressionCounts.track(impression.feature, now, 1);
-            // Keep track by unique key
-            uniqueKeysTracker.track(impression.keyName, impression.feature);
-            // Do not store impressions
-            return false;
+        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/cjs/trackers/strategy/strategyOptimized.js

@@ -6,19 +6,29 @@ var time_1 = require("../../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 impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @returns Optimized strategy
+ * @param impressionsCounter - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @returns IStrategyResult
  */
-function strategyOptimizedFactory(impressionsObserver, impressionCounts) {
+function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {
     return {
-        process: function (impression) {
-            impression.pt = impressionsObserver.testAndSet(impression);
-            var now = Date.now();
-            // Increments impression counter per featureName
-            if (impression.pt)
-                impressionCounts.track(impression.feature, now, 1);
-            // Checks if the impression should be added in queue to be sent
-            return (!impression.pt || impression.pt < (0, time_1.truncateTimeFrame)(now)) ? true : false;
+        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 < (0, time_1.truncateTimeFrame)(now)) {
+                    impressionsToStore.push(impression);
+                }
+            });
+            return {
+                impressionsToStore: impressionsToStore,
+                impressionsToListener: impressions,
+                deduped: impressions.length - impressionsToStore.length
+            };
         }
     };
 }

package/cjs/utils/settingsValidation/index.js

@@ -139,7 +139,7 @@ function settingsValidation(config, validationParams) {
             withDefaults.core.key = 'localhost_key';
         }
         else {
-            // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+            // Keeping same behavior than JS SDK: if settings key or TT are invalid,
             // `false` value is used as bound key/TT of the default client, which leads to some issues.
             // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
             withDefaults.core.key = (0, key_1.validateKey)(log, maybeKey, constants_2.LOG_PREFIX_CLIENT_INSTANTIATION);

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

package/esm/evaluator/index.js

@@ -98,14 +98,12 @@ function getEvaluation(log, splitJSON, key, attributes, storage) {
             return evaluation.then(function (result) {
                 result.changeNumber = split_1.getChangeNumber();
                 result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
-                result.track = splitJSON.trackImpressions;
                 return result;
             });
         }
         else {
             evaluation.changeNumber = split_1.getChangeNumber(); // Always sync and optional
             evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
-            evaluation.track = splitJSON.trackImpressions;
         }
     }
     return evaluation;

package/esm/evaluator/matchers/large_segment.js

@@ -1,12 +1,6 @@
-import { thenable } from '../../utils/promise/thenable';
 export function largeSegmentMatcherContext(largeSegmentName, storage) {
     return function largeSegmentMatcher(key) {
         var isInLargeSegment = storage.largeSegments ? storage.largeSegments.isInSegment(largeSegmentName, key) : false;
-        if (thenable(isInLargeSegment)) {
-            isInLargeSegment.then(function (result) {
-                return result;
-            });
-        }
         return isInLargeSegment;
     };
 }

package/esm/evaluator/matchers/segment.js

@@ -1,12 +1,6 @@
-import { thenable } from '../../utils/promise/thenable';
 export function segmentMatcherContext(segmentName, storage) {
     return function segmentMatcher(key) {
         var isInSegment = storage.segments.isInSegment(segmentName, key);
-        if (thenable(isInSegment)) {
-            isInSegment.then(function (result) {
-                return result;
-            });
-        }
         return isInSegment;
     };
 }

package/esm/listeners/browser.js

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

package/esm/listeners/node.js

@@ -40,7 +40,7 @@ var NodeSignalListener = /** @class */ (function () {
         var wrapUp = function () {
             // Cleaned up, remove handlers.
             _this.stop();
-            // This handler prevented the default behaviour, start again.
+            // This handler prevented the default behavior, start again.
             // eslint-disable-next-line no-undef
             process.kill(process.pid, SIGTERM);
         };
@@ -53,7 +53,7 @@ var NodeSignalListener = /** @class */ (function () {
             this.settings.log.error(LOG_PREFIX_CLEANUP + "Error with Split SDK graceful shutdown: " + err);
         }
         if (thenable(handlerResult)) {
-            // Always exit, even with errors. The promise is returned for UT purposses.
+            // Always exit, even with errors. The promise is returned for UT purposes.
             return handlerResult.then(wrapUp).catch(wrapUp);
         }
         else {

package/esm/readiness/readinessManager.js

@@ -1,5 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
+import { STORAGE_LOCALSTORAGE } from '../utils/constants';
 function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {
         splitsArrived: false,
@@ -80,6 +81,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     function checkIsReadyOrUpdate(diff) {
+        var _a;
         if (isDestroyed)
             return;
         if (isReady) {
@@ -98,6 +100,10 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 isReady = true;
                 try {
                     syncLastUpdate();
+                    if (!isReadyFromCache && ((_a = settings.storage) === null || _a === void 0 ? void 0 : _a.type) === STORAGE_LOCALSTORAGE) {
+                        isReadyFromCache = true;
+                        gate.emit(SDK_READY_FROM_CACHE);
+                    }
                     gate.emit(SDK_READY);
                 }
                 catch (e) {