@splitsoftware/splitio-commons 1.17.1-rc.2 → 1.17.1-rc.3

package/cjs/readiness/readinessManager.js

@@ -45,17 +45,14 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         splits.once(constants_1.SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
+    var readyTimeoutId;
     function timeout() {
-        if (hasTimedout)
+        if (hasTimedout || isReady)
             return;
         hasTimedout = true;
         syncLastUpdate();
         gate.emit(constants_1.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
-    var readyTimeoutId;
-    if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
-    }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
     splits.on(constants_1.SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -116,6 +113,11 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
+        init: function () {
+            if (readyTimeout > 0) {
+                readyTimeoutId = setTimeout(timeout, readyTimeout);
+            }
+        },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -14,7 +14,7 @@ var identity_1 = require("./identity");
  * Therefore, clients don't have a bound TT for the track method.
  */
 function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log, whenInit = params.whenInit;
     var mainClientInstance = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)(params), key);
     var parsedDefaultKey = (0, key_2.keyParser)(key);
     var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey);
@@ -47,15 +47,18 @@ function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager,
+                syncManager: sharedSyncManager_1,
             }), true), validKey);
-            sharedSyncManager && sharedSyncManager.start();
+            whenInit(function () {
+                sharedSdkReadiness_1.readinessManager.init();
+                sharedSyncManager_1 && sharedSyncManager_1.start();
+            });
             log.info(constants_1.NEW_SHARED_CLIENT);
         }
         else {

package/cjs/sdkClient/sdkClientMethodCSWithTT.js

@@ -16,7 +16,7 @@ var identity_1 = require("./identity");
  * (default client) or the client method (shared clients).
  */
 function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log, whenInit = params.whenInit;
     var mainClientInstance = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)(params), key, trafficType);
     var parsedDefaultKey = (0, key_2.keyParser)(key);
     var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey, trafficType);
@@ -56,15 +56,18 @@ function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager,
+                syncManager: sharedSyncManager_1,
             }), true), validKey, validTrafficType);
-            sharedSyncManager && sharedSyncManager.start();
+            whenInit(function () {
+                sharedSdkReadiness_1.readinessManager.init();
+                sharedSyncManager_1 && sharedSyncManager_1.start();
+            });
             log.info(constants_1.NEW_SHARED_CLIENT);
         }
         else {

package/cjs/sdkFactory/index.js

@@ -19,12 +19,19 @@ var constants_3 = require("../utils/constants");
  * Modular SDK factory
  */
 function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, isPure = params.isPure;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+    // initialization
+    var isInit = false;
+    var initCallbacks = [];
+    function whenInit(cb) {
+        if (isInit)
+            cb();
+        else
+            initCallbacks.push(cb);
+    }
     var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -58,11 +65,11 @@ function sdkFactory(params) {
         default:
             strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
     }
-    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
+    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, whenInit: whenInit };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -70,8 +77,22 @@ function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
+    function init() {
+        if (isInit)
+            return;
+        isInit = true;
+        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+        (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+        readiness.init();
+        storage.init && storage.init();
+        uniqueKeysTracker && uniqueKeysTracker.start();
+        syncManager && syncManager.start();
+        signalListener && signalListener.start();
+        initCallbacks.forEach(function (cb) { return cb(); });
+        initCallbacks.length = 0;
+    }
+    if (!isPure)
+        init();
     log.info(constants_1.NEW_FACTORY);
     // @ts-ignore
     return (0, objectAssign_1.objectAssign)({
@@ -88,6 +109,6 @@ function sdkFactory(params) {
         destroy: function () {
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
-    }, extraProps && extraProps(ctx));
+    }, extraProps && extraProps(ctx), isPure && { init: init });
 }
 exports.sdkFactory = sdkFactory;

package/cjs/storages/dataLoader.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSnapshot = exports.loadData = void 0;
 var sets_1 = require("../utils/lang/sets");
+var key_1 = require("../utils/key");
 /**
  * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
  * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
@@ -15,7 +16,7 @@ var sets_1 = require("../utils/lang/sets");
  * @TODO add logs, and input validation in this module, in favor of size reduction.
  * @TODO unit tests
  */
-function loadData(preloadedData, storage, userKey) {
+function loadData(preloadedData, storage, matchingKey) {
     // Do not load data if current preloadedData is empty
     if (Object.keys(preloadedData).length === 0)
         return;
@@ -31,21 +32,21 @@ function loadData(preloadedData, storage, userKey) {
         // 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(splitsData.map(function (split) { return ([split.name, split]); }));
     }
-    if (userKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
+    if (matchingKey) { // add mySegments data (client-side)
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userKeys = segmentsData[segmentName];
-                return userKeys.indexOf(userKey) > -1;
+                var matchingKeys = segmentsData[segmentName];
+                return matchingKeys.indexOf(matchingKey) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
     }
     else { // add segments data (server-side)
         Object.keys(segmentsData).filter(function (segmentName) {
-            var userKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, userKeys);
+            var matchingKeys = segmentsData[segmentName];
+            storage.segments.addToSegment(segmentName, matchingKeys);
         });
     }
 }
@@ -53,8 +54,7 @@ exports.loadData = loadData;
 function getSnapshot(storage, userKeys) {
     return {
         // lastUpdated: Date.now(),
-        // @ts-ignore accessing private prop
-        since: storage.splits.changeNumber,
+        since: storage.splits.getChangeNumber(),
         splitsData: storage.splits.getAll(),
         segmentsData: userKeys ?
             undefined : // @ts-ignore accessing private prop
@@ -64,8 +64,7 @@ function getSnapshot(storage, userKeys) {
             }, {}),
         mySegmentsData: userKeys ?
             userKeys.reduce(function (prev, userKey) {
-                // @ts-ignore accessing private prop
-                prev[userKey] = storage.shared ?
+                prev[(0, key_1.getMatching)(userKey)] = storage.shared ?
                     // Client-side segments
                     // @ts-ignore accessing private prop
                     Object.keys(storage.shared(userKey).segments.segmentCache) :

package/cjs/storages/inLocalStorage/index.js

@@ -37,9 +37,6 @@ function InLocalStorage(options) {
         var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
-        if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-            Promise.resolve().then(onReadyFromCacheCb);
-        }
         return {
             splits: splits,
             segments: segments,
@@ -49,6 +46,11 @@ function InLocalStorage(options) {
             events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
+            init: function () {
+                if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+                    Promise.resolve().then(onReadyFromCacheCb);
+                }
+            },
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);

package/cjs/storages/inRedis/RedisAdapter.js

@@ -20,7 +20,7 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false
+    lazyConnect: false // @TODO true to avoid side-effects on instantiation.
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.

package/cjs/storages/pluggable/index.js

@@ -58,6 +58,7 @@ function PluggableStorage(options) {
         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 connectPromise;
         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) || isSyncronizer ?
@@ -75,37 +76,6 @@ function PluggableStorage(options) {
                 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 (isSyncronizer) {
-                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-                return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                    var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
-                    if (hash !== currentHash) {
-                        log.info(constants_2.LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
-                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                    }
-                }).then(function () {
-                    onReadyCb();
-                });
-            }
-            else {
-                // Start periodic flush of async storages if not running synchronizer (producer mode)
-                if (impressionCountsCache && impressionCountsCache.start)
-                    impressionCountsCache.start();
-                if (uniqueKeysCache && uniqueKeysCache.start)
-                    uniqueKeysCache.start();
-                if (telemetry && telemetry.recordConfig)
-                    telemetry.recordConfig();
-                onReadyCb();
-            }
-        }).catch(function (e) {
-            e = e || new Error('Error connecting wrapper');
-            onReadyCb(e);
-            return e; // Propagate error for shared clients
-        });
         return {
             splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
@@ -114,6 +84,41 @@ function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
+            init: function () {
+                if (connectPromise)
+                    return connectPromise;
+                // Connects to wrapper and emits SDK_READY event on main client
+                return connectPromise = wrapper.connect().then(function () {
+                    if (isSyncronizer) {
+                        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                        return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                            var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
+                            if (hash !== currentHash) {
+                                log.info(constants_2.LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+                                return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                                    return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                                }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                            }
+                        }).then(function () {
+                            onReadyCb();
+                        });
+                    }
+                    else {
+                        // Start periodic flush of async storages if not running synchronizer (producer mode)
+                        if (impressionCountsCache && impressionCountsCache.start)
+                            impressionCountsCache.start();
+                        if (uniqueKeysCache && uniqueKeysCache.start)
+                            uniqueKeysCache.start();
+                        if (telemetry && telemetry.recordConfig)
+                            telemetry.recordConfig();
+                        onReadyCb();
+                    }
+                }).catch(function (e) {
+                    e = e || new Error('Error connecting wrapper');
+                    onReadyCb(e);
+                    return e; // Propagate error for shared clients
+                });
+            },
             // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
                 return Promise.all(isSyncronizer ? [] : [
@@ -123,7 +128,7 @@ function PluggableStorage(options) {
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                connectPromise.then(onReadyCb);
+                this.init().then(onReadyCb);
                 return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

package/cjs/trackers/eventTracker.js

@@ -12,7 +12,7 @@ var mode_1 = require("../utils/settingsValidation/mode");
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -23,14 +23,16 @@ function eventTrackerFactory(settings, eventsCache, integrationsManager, telemet
             log.info(constants_1.EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
                 // 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
-                    var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
-                    if (properties)
-                        eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
-                    // integrationsManager does not throw errors (they are internally handled by each integration module)
-                    integrationsManager.handleEvent(eventDataCopy);
-                }, 0);
+                whenInit(function () {
+                    setTimeout(function () {
+                        // copy of event, to avoid unexpected behaviour if modified by integrations
+                        var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
+                        if (properties)
+                            eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
+                        // integrationsManager does not throw errors (they are internally handled by each integration module)
+                        integrationsManager.handleEvent(eventDataCopy);
+                    });
+                });
             }
         }
         else {

package/cjs/trackers/impressionsTracker.js

@@ -14,7 +14,7 @@ var constants_2 = require("../utils/constants");
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-function impressionsTrackerFactory(settings, impressionsCache, strategy, 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) {
@@ -54,18 +54,20 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
                         sdkLanguageVersion: version
                     };
                     // 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(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
-                        }
-                    }, 0);
+                    whenInit(function () {
+                        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(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/cjs/trackers/uniqueKeysTracker.js

@@ -19,9 +19,6 @@ var noopFilterAdapter = {
 function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -30,6 +27,11 @@ function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

package/esm/readiness/readinessManager.js

@@ -42,17 +42,14 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
+    var readyTimeoutId;
     function timeout() {
-        if (hasTimedout)
+        if (hasTimedout || isReady)
             return;
         hasTimedout = true;
         syncLastUpdate();
         gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
-    var readyTimeoutId;
-    if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
-    }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
     splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -113,6 +110,11 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
+        init: function () {
+            if (readyTimeout > 0) {
+                readyTimeoutId = setTimeout(timeout, readyTimeout);
+            }
+        },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();

package/esm/sdkClient/sdkClientMethodCS.js

@@ -11,7 +11,7 @@ import { buildInstanceId } from './identity';
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log, whenInit = params.whenInit;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -44,15 +44,18 @@ export function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager,
+                syncManager: sharedSyncManager_1,
             }), true), validKey);
-            sharedSyncManager && sharedSyncManager.start();
+            whenInit(function () {
+                sharedSdkReadiness_1.readinessManager.init();
+                sharedSyncManager_1 && sharedSyncManager_1.start();
+            });
             log.info(NEW_SHARED_CLIENT);
         }
         else {

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -13,7 +13,7 @@ import { buildInstanceId } from './identity';
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log, whenInit = params.whenInit;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
@@ -53,15 +53,18 @@ export function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager,
+                syncManager: sharedSyncManager_1,
             }), true), validKey, validTrafficType);
-            sharedSyncManager && sharedSyncManager.start();
+            whenInit(function () {
+                sharedSdkReadiness_1.readinessManager.init();
+                sharedSyncManager_1 && sharedSyncManager_1.start();
+            });
             log.info(NEW_SHARED_CLIENT);
         }
         else {

package/esm/sdkFactory/index.js

@@ -16,12 +16,19 @@ import { NONE, OPTIMIZED } from '../utils/constants';
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, isPure = params.isPure;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    // initialization
+    var isInit = false;
+    var initCallbacks = [];
+    function whenInit(cb) {
+        if (isInit)
+            cb();
+        else
+            initCallbacks.push(cb);
+    }
     var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -55,11 +62,11 @@ export function sdkFactory(params) {
         default:
             strategy = strategyDebugFactory(observer);
     }
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, whenInit: whenInit };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -67,8 +74,22 @@ export function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
+    function init() {
+        if (isInit)
+            return;
+        isInit = true;
+        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+        validateAndTrackApiKey(log, settings.core.authorizationKey);
+        readiness.init();
+        storage.init && storage.init();
+        uniqueKeysTracker && uniqueKeysTracker.start();
+        syncManager && syncManager.start();
+        signalListener && signalListener.start();
+        initCallbacks.forEach(function (cb) { return cb(); });
+        initCallbacks.length = 0;
+    }
+    if (!isPure)
+        init();
     log.info(NEW_FACTORY);
     // @ts-ignore
     return objectAssign({
@@ -85,5 +106,5 @@ export function sdkFactory(params) {
         destroy: function () {
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
-    }, extraProps && extraProps(ctx));
+    }, extraProps && extraProps(ctx), isPure && { init: init });
 }