Remove whenInit callback mechanism from trackers. It was originally added to handle React SDK side effects, but it’s unnecessary if the user calls client.track inside an effect.

Author: EmilianoSanchez

src/sdkFactory/index.ts

@@ -35,12 +35,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   // initialization
   let hasInit = false;
-  const initCallbacks: (() => void)[] = [];
-
-  function whenInit(cb: () => void) {
-    if (hasInit) cb();
-    else initCallbacks.push(cb);
-  }
 
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
@@ -82,8 +76,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
       strategyDebugFactory(observer) :
       noneStrategy;
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
@@ -111,9 +105,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     uniqueKeysTracker.start();
     syncManager && syncManager.start();
     signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
   }
 
   log.info(NEW_FACTORY, [settings.version]);

src/trackers/__tests__/eventTracker.spec.ts

@@ -29,15 +29,13 @@ const fakeEvent = {
   }
 };
 
-const fakeWhenInit = (cb: () => void) => cb();
-
 /* Tests */
 describe('Event Tracker', () => {
 
   test('Tracker API', () => {
     expect(typeof eventTrackerFactory).toBe('function'); // The module should return a function which acts as a factory.
 
-    const instance = eventTrackerFactory(fullSettings, fakeEventsCache, fakeWhenInit, fakeIntegrationsManager);
+    const instance = eventTrackerFactory(fullSettings, fakeEventsCache, fakeIntegrationsManager);
 
     expect(typeof instance.track).toBe('function'); // The instance should implement the track method.
   });
@@ -53,7 +51,7 @@ describe('Event Tracker', () => {
       }
     });
     // @ts-ignore
-    const tracker = eventTrackerFactory(fullSettings, fakeEventsCache, fakeWhenInit, fakeIntegrationsManager, fakeTelemetryCache);
+    const tracker = eventTrackerFactory(fullSettings, fakeEventsCache, fakeIntegrationsManager, fakeTelemetryCache);
     const result1 = tracker.track(fakeEvent, 1);
 
     expect(fakeEventsCache.track.mock.calls[0]).toEqual([fakeEvent, 1]); // Should be present in the event cache.
@@ -94,7 +92,7 @@ describe('Event Tracker', () => {
     const settings = { ...fullSettings };
     const fakeEventsCache = { track: jest.fn(() => true) };
 
-    const tracker = eventTrackerFactory(settings, fakeEventsCache, fakeWhenInit);
+    const tracker = eventTrackerFactory(settings, fakeEventsCache);
 
     expect(tracker.track(fakeEvent)).toBe(true);
     expect(fakeEventsCache.track).toBeCalledTimes(1); // event should be tracked if userConsent is undefined

src/trackers/__tests__/impressionsTracker.spec.ts

@@ -34,8 +34,6 @@ const fakeSettingsWithListener = {
   ...fakeSettings,
   impressionListener: fakeListener
 };
-const fakeWhenInit = (cb: () => void) => cb();
-
 const fakeNoneStrategy = {
   process: jest.fn(() => false)
 };
@@ -53,7 +51,7 @@ describe('Impressions Tracker', () => {
   const strategy = strategyDebugFactory(impressionObserverCSFactory());
 
   test('Should be able to track impressions (in DEBUG mode without Previous Time).', () => {
-    const tracker = impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategy, fakeWhenInit);
+    const tracker = impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategy);
 
     const imp1 = {
       feature: '10',
@@ -73,7 +71,7 @@ describe('Impressions Tracker', () => {
   });
 
   test('Tracked impressions should be sent to impression listener and integration manager when we invoke .track()', (done) => {
-    const tracker = impressionsTrackerFactory(fakeSettingsWithListener, fakeImpressionsCache, fakeNoneStrategy, strategy, fakeWhenInit, fakeIntegrationsManager);
+    const tracker = impressionsTrackerFactory(fakeSettingsWithListener, fakeImpressionsCache, fakeNoneStrategy, strategy, fakeIntegrationsManager);
 
     const fakeImpression = {
       feature: 'impression'
@@ -147,8 +145,8 @@ describe('Impressions Tracker', () => {
     impression3.time = 1234567891;
 
     const trackers = [
-      impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyDebugFactory(impressionObserverSSFactory()), fakeWhenInit, undefined),
-      impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyDebugFactory(impressionObserverCSFactory()), fakeWhenInit, undefined)
+      impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyDebugFactory(impressionObserverSSFactory()), undefined),
+      impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyDebugFactory(impressionObserverCSFactory()), undefined)
     ];
 
     expect(fakeImpressionsCache.track).not.toBeCalled(); // storage method should not be called until impressions are tracked.
@@ -175,7 +173,7 @@ describe('Impressions Tracker', () => {
     impression3.time = Date.now();
 
     const impressionCountsCache = new ImpressionCountsCacheInMemory();
-    const tracker = impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyOptimizedFactory(impressionObserverCSFactory(), impressionCountsCache), fakeWhenInit, undefined, fakeTelemetryCache as any);
+    const tracker = impressionsTrackerFactory(fakeSettings, fakeImpressionsCache, fakeNoneStrategy, strategyOptimizedFactory(impressionObserverCSFactory(), impressionCountsCache), undefined, fakeTelemetryCache as any);
 
     expect(fakeImpressionsCache.track).not.toBeCalled(); // cache method should not be called by just creating a tracker
 
@@ -198,7 +196,7 @@ describe('Impressions Tracker', () => {
   test('Should track or not impressions depending on user consent status', () => {
     const settings = { ...fullSettings };
 
-    const tracker = impressionsTrackerFactory(settings, fakeImpressionsCache, fakeNoneStrategy, strategy, fakeWhenInit);
+    const tracker = impressionsTrackerFactory(settings, fakeImpressionsCache, fakeNoneStrategy, strategy);
 
     tracker.track([{ imp: impression }]);
     expect(fakeImpressionsCache.track).toBeCalledTimes(1); // impression should be tracked if userConsent is undefined

src/trackers/eventTracker.ts

@@ -17,7 +17,6 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
-  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -33,15 +32,13 @@ export function eventTrackerFactory(
     if (tracked) {
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
-        whenInit(() => {
-          // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(() => {
-            // copy of event, to avoid unexpected behavior if modified by integrations
-            const 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(() => {
+          // copy of event, to avoid unexpected behavior if modified by integrations
+          const 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);
         });
       }
     } else {

src/trackers/impressionsTracker.ts

@@ -15,7 +15,6 @@ export function impressionsTrackerFactory(
   impressionsCache: IImpressionsCacheBase,
   noneStrategy: IStrategy,
   strategy: IStrategy,
-  whenInit: (cb: () => void) => void,
   integrationsManager?: IImpressionsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
@@ -67,18 +66,16 @@ export function impressionsTrackerFactory(
             sdkLanguageVersion: version
           };
 
-          whenInit(() => {
-            // Wrap in a timeout because we don't want it to be blocking.
-            setTimeout(() => {
-              // integrationsManager.handleImpression does not throw errors
-              if (integrationsManager) integrationsManager.handleImpression(impressionData);
+          // Wrap in a timeout because we don't want it to be blocking.
+          setTimeout(() => {
+            // 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]);
-              }
-            });
+            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]);
+            }
           });
         }
       }