@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/esm/sync/streaming/parseUtils.js

@@ -27,25 +27,25 @@ function decompress(data, compression) {
         return algorithms.gunzipSync(binData);
     if (compression === ZLIB)
         return algorithms.unzlibSync(binData);
-    throw new Error("Invalid compression algorithm #" + compression);
+    throw new Error("Invalid compression algorithm #".concat(compression));
 }
 /**
- * Decode, decompress and parse the provided 'data' into a KeyList object
+ * Decode, decompress and parse the provided 'data' into an object of type T
  *
  * @param data - base64 encoded string
  * @param compression - 1 GZIP, 2 ZLIB
  * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns keyList
+ * @returns parsed object
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data, compression, avoidPrecisionLoss) {
+export function parseCompressedData(data, compression, avoidPrecisionLoss) {
     if (avoidPrecisionLoss === void 0) { avoidPrecisionLoss = true; }
-    var binKeyList = decompress(data, compression);
-    var strKeyList = Uint8ArrayToString(binKeyList);
-    // replace numbers to strings, to avoid losing precision
+    var binData = decompress(data, compression);
+    var str = Uint8ArrayToString(binData);
+    // replace numbers to strings, to avoid losing precision (e.g., 64-bit IDs in KeyList)
     if (avoidPrecisionLoss)
-        strKeyList = strKeyList.replace(/\d+/g, '"$&"');
-    return JSON.parse(strKeyList);
+        str = str.replace(/\d+/g, '"$&"');
+    return JSON.parse(str);
 }
 /**
  * Decode, decompress and parse the provided 'data' into a Bitmap object
@@ -77,7 +77,7 @@ export function isInBitmap(bitmap, hash64hex) {
  */
 export function parseFFUpdatePayload(compression, data) {
     return compression > 0 ?
-        parseKeyList(data, compression, false) :
+        parseCompressedData(data, compression, false) :
         JSON.parse(decodeFromBase64(data));
 }
 var DEFAULT_MAX_INTERVAL = 60000;

package/esm/sync/streaming/pushManager.js

@@ -3,15 +3,15 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -42,8 +42,8 @@ export function pushManagerFactory(params, pollingManager) {
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
-    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
+    // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+    var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -51,10 +51,10 @@ export function pushManagerFactory(params, pollingManager) {
     var clients = {};
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
-    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
-    // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
     // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
     var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
@@ -93,11 +93,11 @@ export function pushManagerFactory(params, pollingManager) {
         authenticate(userKeys).then(function (authData) {
             if (disconnected)
                 return;
-            // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+            // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
             // close the sseClient in case the org has been bloqued while the instance was connected to streaming
             if (!authData.pushEnabled) {
                 log.info(STREAMING_DISABLED);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
@@ -112,7 +112,7 @@ export function pushManagerFactory(params, pollingManager) {
             // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
             if (error.statusCode >= 400 && error.statusCode < 500) {
                 telemetryTracker.streamingEvent(AUTH_REJECTION);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // Handle other HTTP and network errors as recoverable errors
@@ -136,7 +136,7 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.stop();
+        definitionsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
@@ -152,7 +152,7 @@ export function pushManagerFactory(params, pollingManager) {
         connectPushRetryBackoff.reset();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
-    pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
         disabled = true;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
@@ -178,9 +178,9 @@ export function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
-    pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+    pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
@@ -203,7 +203,7 @@ export function pushManagerFactory(params, pollingManager) {
             case UpdateStrategy.KeyList: {
                 var keyList = void 0, added_1, removed_1;
                 try {
-                    keyList = parseKeyList(parsedData.d, parsedData.c);
+                    keyList = parseCompressedData(parsedData.d, parsedData.c);
                     added_1 = new Set(keyList.a);
                     removed_1 = new Set(keyList.r);
                 }

package/esm/sync/submitters/impressionsSubmitter.js

@@ -4,14 +4,14 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels, data) {
+export function fromImpressionsCollector(sendLabels, entityType, data) {
     var groupedByFeature = groupBy(data, 'feature');
     var dto = [];
     forOwn(groupedByFeature, function (value, name) {
         dto.push({
             f: name,
             i: value.map(function (entry) {
-                var keyImpression = {
+                return {
                     k: entry.keyName,
                     t: entry.treatment,
                     m: entry.time,
@@ -19,9 +19,9 @@ export function fromImpressionsCollector(sendLabels, data) {
                     r: sendLabels ? entry.label : undefined,
                     b: entry.bucketingKey,
                     pt: entry.pt,
-                    properties: entry.properties // Properties
+                    properties: entry.properties,
+                    et: entityType, // Definition type
                 };
-                return keyImpression;
             })
         });
     });
@@ -31,9 +31,9 @@ export function fromImpressionsCollector(sendLabels, data) {
  * Submitter that periodically posts impressions data
  */
 export function impressionsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions;
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions, entityType = params.entityType;
     // retry impressions only once.
-    var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
+    var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
     // register impressions submitter to be executed when impressions cache is full
     impressions.setOnFullQueueCb(function () {
         if (syncTask.isRunning()) {

package/esm/sync/submitters/submitter.js

@@ -13,7 +13,7 @@ export function submitterFactory(log, postClient, sourceCache, postRate, fromCac
         if (sourceCache.isEmpty() && !data)
             return Promise.resolve();
         data = sourceCache.pop(data);
-        var dataCountMessage = typeof data.length === 'number' ? data.length + " " + dataName : dataName;
+        var dataCountMessage = typeof data.length === 'number' ? "".concat(data.length, " ").concat(dataName) : dataName;
         log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCountMessage]);
         var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
         if (!maxRetries)

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,13 +102,12 @@ export function telemetrySubmitterFactory(params) {
     var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness;
     var stopTimer = timer(now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
-    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/esm/sync/syncManagerOnline.js

@@ -3,8 +3,9 @@ import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
+import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -12,15 +13,17 @@ import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
+ * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionChangesFetcherFactory) {
+    if (definitionChangesFetcherFactory === void 0) { definitionChangesFetcherFactory = splitChangesFetcherFactory; }
     /**
      * 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, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionChangesFetcherFactory(params));
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :
@@ -74,7 +77,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments

package/esm/trackers/eventTracker.js

@@ -9,26 +9,24 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache - cache to save events
  * @param integrationsManager - optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
-        var msg = "event of type \"" + eventTypeId + "\" for traffic type \"" + trafficTypeName + "\". Key: " + key + ". Value: " + value + ". Timestamp: " + timestamp + ". " + (properties ? 'With properties.' : 'With no properties.');
+        var msg = "event of type \"".concat(eventTypeId, "\" for traffic type \"").concat(trafficTypeName, "\". Key: ").concat(key, ". Value: ").concat(value, ". Timestamp: ").concat(timestamp, ". ").concat(properties ? 'With properties.' : 'With no properties.');
         if (tracked) {
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                whenInit(function () {
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // copy of event, to avoid unexpected behavior if modified by integrations
-                        var eventDataCopy = objectAssign({}, eventData);
-                        if (properties)
-                            eventDataCopy.properties = objectAssign({}, properties);
-                        // integrationsManager does not throw errors (they are internally handled by each integration module)
-                        integrationsManager.handleEvent(eventDataCopy);
-                    });
+                // Wrap in a timeout because we don't want it to be blocking.
+                setTimeout(function () {
+                    // copy of event, to avoid unexpected behavior if modified by integrations
+                    var eventDataCopy = objectAssign({}, eventData);
+                    if (properties)
+                        eventDataCopy.properties = objectAssign({}, properties);
+                    // integrationsManager does not throw errors (they are internally handled by each integration module)
+                    integrationsManager.handleEvent(eventDataCopy);
                 });
             }
         }

package/esm/trackers/impressionObserver/buildKey.js

@@ -1,3 +1,3 @@
 export function buildKey(impression) {
-    return impression.keyName + ":" + impression.feature + ":" + impression.treatment + ":" + impression.label + ":" + impression.changeNumber;
+    return "".concat(impression.keyName, ":").concat(impression.feature, ":").concat(impression.treatment, ":").concat(impression.label, ":").concat(impression.changeNumber);
 }

package/esm/trackers/impressionsTracker.js

@@ -1,13 +1,32 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
-import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
+import { CONSENT_DECLINED, DEBUG, DEDUPED, OPTIMIZED, QUEUED } from '../utils/constants';
+import { strategyDebugFactory } from './strategy/strategyDebug';
+import { strategyNoneFactory } from './strategy/strategyNone';
+import { strategyOptimizedFactory } from './strategy/strategyOptimized';
+import { uniqueKeysTrackerFactory } from './uniqueKeysTracker';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+export function impressionsTrackerFactory(params, storage, integrationsManager) {
+    var settings = params.settings, impressionsObserverFactory = params.impressionsObserverFactory, filterAdapterFactory = params.filterAdapterFactory;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version, impressionsMode = settings.sync.impressionsMode;
+    var observer = impressionsObserverFactory();
+    var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
+    var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
+    var strategy = impressionsMode === OPTIMIZED ?
+        strategyOptimizedFactory(observer, storage.impressionCounts) :
+        impressionsMode === DEBUG ?
+            strategyDebugFactory(observer) :
+            noneStrategy;
     return {
+        start: function () {
+            uniqueKeysTracker.start();
+        },
+        stop: function () {
+            uniqueKeysTracker.stop();
+        },
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
                 return;
@@ -20,7 +39,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
             var impressionsLength = impressions.length;
             var impressionsToStoreLength = impressionsToStore.length;
             if (impressionsToStoreLength) {
-                var res = impressionsCache.track(impressionsToStore.map(function (item) { return item.imp; }));
+                var res = storage.impressions.track(impressionsToStore.map(function (item) { return item.imp; }));
                 // If we're on an async storage, handle error and log it.
                 if (thenable(res)) {
                     res.then(function () {
@@ -32,9 +51,9 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                 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, impressionsToStoreLength);
-                        telemetryCache.recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
+                    if (storage.telemetry) {
+                        storage.telemetry.recordImpressionStats(QUEUED, impressionsToStoreLength);
+                        storage.telemetry.recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
                     }
                 }
             }
@@ -49,20 +68,18 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    whenInit(function () {
-                        // Wrap in a timeout because we don't want it to be blocking.
-                        setTimeout(function () {
-                            // integrationsManager.handleImpression does not throw errors
-                            if (integrationsManager)
-                                integrationsManager.handleImpression(impressionData);
-                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (impressionListener)
-                                    impressionListener.logImpression(impressionData);
-                            }
-                            catch (err) {
-                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                            }
-                        });
+                    // Wrap in a timeout because we don't want it to be blocking.
+                    setTimeout(function () {
+                        // integrationsManager.handleImpression does not throw errors
+                        if (integrationsManager)
+                            integrationsManager.handleImpression(impressionData);
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                            if (impressionListener)
+                                impressionListener.logImpression(impressionData);
+                        }
+                        catch (err) {
+                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+                        }
                     });
                 };
                 for (var i = 0; i < impressionsLength; i++) {

package/esm/trackers/uniqueKeysTracker.js

@@ -19,7 +19,7 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     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");
+                log.debug("".concat(LOG_PREFIX_UNIQUE_KEYS_TRACKER, "The feature ").concat(featureName, " and key ").concat(key, " exist in the filter"));
                 return;
             }
             uniqueKeysCache.track(key, featureName);

package/esm/utils/Backoff.js

@@ -24,6 +24,26 @@ var Backoff = /** @class */ (function () {
         this.attempts++;
         return delayInMillis;
     };
+    /**
+     * Schedule a delayed call to `cb`
+     * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+     */
+    Backoff.prototype.scheduleCallAsync = function () {
+        var _this = this;
+        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+        if (this.timeoutID)
+            clearTimeout(this.timeoutID);
+        this.attempts++;
+        return new Promise(function (resolve, reject) {
+            _this.timeoutID = setTimeout(function () {
+                _this.timeoutID = undefined;
+                _this.cb().then(resolve, reject);
+            }, delayInMillis);
+        });
+    };
+    /**
+     * Reset the backoff attempts
+     */
     Backoff.prototype.reset = function () {
         this.attempts = 0;
         if (this.timeoutID) {