@splitsoftware/splitio 10.17.1 → 10.17.3-rc.1

package/src/sync/SSEHandler/index.js

@@ -1,110 +0,0 @@
-import { errorParser, messageParser } from './NotificationParser';
-import notificationKeeperFactory from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, SPLIT_UPDATE, SEGMENT_UPDATE, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SPLIT_KILL, OCCUPANCY, CONTROL } from '../constants';
-import logFactory from '../../utils/logger';
-const log = logFactory('splitio-sync:sse-handler');
-
-function isRetryableError(error) {
-  if (error.parsedData && error.parsedData.code) {
-    const code = error.parsedData.code;
-    // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
-    if (40140 <= code && code <= 40149) return true;
-    // Others 4XX errors (e.g., bad request from the SDK)
-    if (40000 <= code && code <= 49999) return false;
-  }
-  // network errors or 5XX HTTP errors
-  return true;
-}
-
-/**
- * Factory for SSEHandler
- *
- * @param {Object} pushEmitter emitter for emitting events related to feedback-loop & update queues
- */
-export default function SSEHandlerFactory(pushEmitter) {
-
-  const notificationKeeper = notificationKeeperFactory(pushEmitter);
-
-  return {
-    handleOpen() {
-      notificationKeeper.handleOpen();
-    },
-
-    /* HTTP & Network errors */
-    handleError(error) {
-      let errorWithParsedData = error;
-      try {
-        errorWithParsedData = errorParser(error);
-      } catch (err) {
-        log.warn(`Error parsing SSE error notification: ${err}`);
-      }
-
-      let errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
-      log.error(`Fail to connect to streaming${errorMessage ? `, with error message: "${errorMessage}"` : ''}`);
-
-      if (isRetryableError(errorWithParsedData)) {
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      } else {
-        pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-      }
-    },
-
-    /* NotificationProcessor */
-    handleMessage(message) {
-      let messageWithParsedData;
-      try {
-        messageWithParsedData = messageParser(message);
-      } catch (err) {
-        log.warn(`Error parsing new SSE message notification: ${err}`);
-        return;
-      }
-
-      const { parsedData, data, channel, timestamp } = messageWithParsedData;
-      log.debug(`New SSE message received, with data: ${data}.`);
-
-      // we only handle update events if streaming is up.
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
-        return;
-
-      switch (parsedData.type) {
-        /* update events */
-        case SPLIT_UPDATE:
-          pushEmitter.emit(SPLIT_UPDATE,
-            parsedData.changeNumber);
-          break;
-        case SEGMENT_UPDATE:
-          pushEmitter.emit(SEGMENT_UPDATE,
-            parsedData.changeNumber,
-            parsedData.segmentName);
-          break;
-        case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(MY_SEGMENTS_UPDATE,
-            parsedData,
-            channel);
-          break;
-        case MY_SEGMENTS_UPDATE_V2:
-          pushEmitter.emit(MY_SEGMENTS_UPDATE_V2,
-            parsedData);
-          break;
-        case SPLIT_KILL:
-          pushEmitter.emit(SPLIT_KILL,
-            parsedData.changeNumber,
-            parsedData.splitName,
-            parsedData.defaultTreatment);
-          break;
-
-        /* occupancy & control events, handled by NotificationManagerKeeper */
-        case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-          break;
-        case CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-          break;
-
-        default:
-          break;
-      }
-    },
-
-  };
-}

package/src/sync/SegmentUpdateWorker/browser.js

@@ -1,67 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * MySegmentUpdateWorker class
- */
-export default class MySegmentUpdateWorker {
-
-  /**
-   *
-   * @param {Object} mySegmentsStorage
-   * @param {Object} mySegmentsProducer
-   */
-  constructor(mySegmentsStorage, mySegmentsProducer) {
-    this.mySegmentsStorage = mySegmentsStorage;
-    this.mySegmentsProducer = mySegmentsProducer;
-    this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-    this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
-    this.put = this.put.bind(this);
-    this.__handleMySegmentUpdateCall = this.__handleMySegmentUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleMySegmentUpdateCall);
-  }
-
-  // Private method
-  // Preconditions: this.mySegmentsProducer.isSynchronizingMySegments === false
-  // @TODO update this block similar to SplitUpdateWorker, once `/mySegments` endpoint provides the changeNumber
-  __handleMySegmentUpdateCall() {
-    if (this.maxChangeNumber > this.currentChangeNumber) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumber = this.maxChangeNumber;
-
-      // fetch mySegments revalidating data if cached
-      this.mySegmentsProducer.synchronizeMySegments(this.segmentsData, true).then((result) => {
-        if (result !== false) // Unlike `Split\SegmentUpdateWorker`, we cannot use `mySegmentsStorage.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-          this.currentChangeNumber = Math.max(this.currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-        if (this.handleNewEvent) {
-          this.__handleMySegmentUpdateCall();
-        } else {
-          this.backoff.scheduleCall();
-        }
-      });
-    }
-  }
-
-  /**
-   * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-   *
-   * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData might be undefined
-   */
-  put(changeNumber, segmentsData) {
-    // @TODO uncomment next line once `/mySegments` endpoint provides the changeNumber
-    // const currentChangeNumber = this.mySegmentsStorage.getChangeNumber();
-
-    if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
-
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-    this.segmentsData = segmentsData;
-
-    if (this.mySegmentsProducer.isSynchronizingMySegments()) return;
-
-    this.__handleMySegmentUpdateCall();
-  }
-
-}

package/src/sync/SegmentUpdateWorker/node.js

@@ -1,73 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * SegmentUpdateWorker class
- */
-export default class SegmentUpdateWorker {
-
-  /**
-   * @param {Object} segmentsStorage
-   * @param {Object} segmentsProducer
-   */
-  constructor(segmentsStorage, segmentsProducer) {
-    this.segmentsStorage = segmentsStorage;
-    this.segmentsProducer = segmentsProducer;
-    this.maxChangeNumbers = {};
-    this.put = this.put.bind(this);
-    this.__handleSegmentUpdateCall = this.__handleSegmentUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleSegmentUpdateCall);
-  }
-
-  // Private method
-  // Preconditions: this.segmentsProducer.isSynchronizingSegments === false
-  // Approach similar to MySegmentUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
-  __handleSegmentUpdateCall() {
-    const segmentsToFetch = Object.keys(this.maxChangeNumbers).filter((segmentName) => {
-      return this.maxChangeNumbers[segmentName] > this.segmentsStorage.getChangeNumber(segmentName);
-    });
-    if (segmentsToFetch.length > 0) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumbers = segmentsToFetch.map(segmentToFetch => this.maxChangeNumbers[segmentToFetch]);
-
-      // fetch segments revalidating data if cached
-      this.segmentsProducer.synchronizeSegment(segmentsToFetch, true).then((result) => {
-        // Unlike `SplitUpdateWorker` where changeNumber is consistent between notification and endpoint, if there is no error,
-        // we must clean the `maxChangeNumbers` of those segments that didn't receive a new update notification during the fetch.
-        if (result !== false) {
-          segmentsToFetch.forEach((fetchedSegment, index) => {
-            if (this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers[index]) this.maxChangeNumbers[fetchedSegment] = -1;
-          });
-        } else {
-          // recursive invocation with backoff if there was some error
-          this.backoff.scheduleCall();
-        }
-
-        // immediate recursive invocation if a new notification was queued during fetch
-        if (this.handleNewEvent) {
-          this.__handleSegmentUpdateCall();
-        }
-      });
-    }
-  }
-
-  /**
-   * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-   *
-   * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-   * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
-   */
-  put(changeNumber, segmentName) {
-    const currentChangeNumber = this.segmentsStorage.getChangeNumber(segmentName);
-
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName]) return;
-
-    this.maxChangeNumbers[segmentName] = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-
-    if (this.segmentsProducer.isSynchronizingSegments()) return;
-
-    this.__handleSegmentUpdateCall();
-  }
-
-}

package/src/sync/SegmentUpdateWorker/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "./node.js",
-  "browser": "./browser.js"
-}

package/src/sync/SplitUpdateWorker/index.js

@@ -1,79 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * SplitUpdateWorker class
- */
-export default class SplitUpdateWorker {
-
-  /**
-   * @param {Object} splitStorage splits cache
-   * @param {Object} splitProducer node producer or full browser producer
-   * @param {Object} splitsEventEmitter
-   */
-  constructor(splitStorage, splitProducer, splitsEventEmitter) {
-    this.splitStorage = splitStorage;
-    this.splitProducer = splitProducer;
-    this.maxChangeNumber = 0;
-    this.splitsEventEmitter = splitsEventEmitter;
-    this.put = this.put.bind(this);
-    this.killSplit = this.killSplit.bind(this);
-    this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleSplitUpdateCall);
-  }
-
-  // Private method
-  // Preconditions: this.splitProducer.isSynchronizingSplits === false
-  __handleSplitUpdateCall() {
-    if (this.maxChangeNumber > this.splitStorage.getChangeNumber()) {
-      this.handleNewEvent = false;
-
-      // fetch splits revalidating data if cached
-      this.splitProducer.synchronizeSplits(true).then(() => {
-        if (this.handleNewEvent) {
-          this.__handleSplitUpdateCall();
-        } else {
-          // fetch new registered segments for server-side API. Not retrying on error
-          if(this.splitProducer.synchronizeSegment) this.splitProducer.synchronizeSegment(undefined, false, true);
-          this.backoff.scheduleCall();
-        }
-      });
-    }
-  }
-
-  /**
-   * Invoked by NotificationProcessor on SPLIT_UPDATE event
-   *
-   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-   */
-  put(changeNumber) {
-    const currentChangeNumber = this.splitStorage.getChangeNumber();
-
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
-
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-
-    if (this.splitProducer.isSynchronizingSplits()) return;
-
-    this.__handleSplitUpdateCall();
-  }
-
-  /**
-   * Invoked by NotificationProcessor on SPLIT_KILL event
-   *
-   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-   * @param {string} splitName name of split to kill
-   * @param {string} defaultTreatment default treatment value
-   */
-  killSplit(changeNumber, splitName, defaultTreatment) {
-    // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
-    this.splitStorage.killLocally(splitName, defaultTreatment, changeNumber).then((updated) => {
-      // trigger an SDK_UPDATE if Split was killed locally
-      if (updated) this.splitsEventEmitter.emit(this.splitsEventEmitter.SDK_SPLITS_ARRIVED, true);
-      // queues the SplitChanges fetch (only if changeNumber is newer)
-      this.put(changeNumber);
-    });
-  }
-
-}

package/src/sync/browser.js

@@ -1,130 +0,0 @@
-import PushManagerFactory from './PushManager';
-import FullProducerFactory from '../producer';
-import PartialProducerFactory from '../producer/browser/Partial';
-import { matching } from '../utils/key/factory';
-import { forOwn, toString } from '../utils/lang';
-import logFactory from '../utils/logger';
-import { PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP } from './constants';
-const log = logFactory('splitio-sync:sync-manager');
-
-/**
- * Factory of sync manager for browser
- *
- * @param context main client context
- */
-export default function BrowserSyncManagerFactory(mainContext) {
-
-  // map of user keys to client contexts
-  const contexts = {};
-  const settings = mainContext.get(mainContext.constants.SETTINGS);
-
-  // call `createInstance` before creating PushManager, since it is in charge of creating the full producer and adding it into the main context.
-  const syncManager = createInstance(false, mainContext);
-  const pushManager = settings.streamingEnabled ? PushManagerFactory(mainContext, contexts) : undefined;
-  const mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-
-  function startPolling() {
-    if (!mainProducer.isRunning()) {
-      log.info('Streaming not available. Starting periodic fetch of data.');
-      forOwn(contexts, function (context) {
-        const producer = context.get(context.constants.PRODUCER);
-        producer.start();
-      });
-    } else {
-      log.info('Streaming couldn\'t connect. Continue periodic fetch of data.');
-    }
-  }
-
-  function stopPollingAndSyncAll() {
-    if (mainProducer.isRunning()) {
-      log.info('PUSH (re)connected. Syncing and stopping periodic fetch of data.');
-      // if polling, stop
-      forOwn(contexts, function (context) {
-        const producer = context.get(context.constants.PRODUCER);
-        producer.stop();
-      });
-    }
-    syncAll();
-  }
-
-  function syncAll() {
-    // fetch splits and segments
-    const mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-    mainProducer.synchronizeSplits();
-    forOwn(contexts, function (context) {
-      const producer = context.get(context.constants.PRODUCER);
-      producer.synchronizeMySegments();
-    });
-  }
-
-  /**
-   * Creates a SyncManager that handles the synchronization of clients (main and shared ones).
-   * Internally, it creates the client producer, adds it into its context, and defines the `start` and `stop` methods that handle synchronization.
-   *
-   * @param {Object} context
-   * @param {boolean} isSharedClient
-   */
-  function createInstance(isSharedClient, context) {
-    const producer = isSharedClient ? PartialProducerFactory(context) : FullProducerFactory(context);
-    const settings = context.get(context.constants.SETTINGS);
-    // we need to stringify the user key (or matching key) in case it is not an string, to hash and pass as query param for authentication
-    const userKey = toString(matching(settings.core.key));
-
-    context.put(context.constants.PRODUCER, producer);
-    if (contexts[userKey]) log.warn('A client with the same user key has already been created. Only the new instance will be properly synchronized.');
-    contexts[userKey] = context;
-
-    return {
-      start() {
-        // start syncing
-        if (pushManager) {
-          if (!isSharedClient) {
-            syncAll(); // initial syncAll (only when main client is created)
-            pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-            pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
-          } else {
-            if (mainProducer.isRunning()) {
-              // if doing polling, we must start the producer periodic fetch of data
-              producer.start();
-            } else {
-              // if not doing polling, we must perform a `producer.synchronizeMySegments` for the initial fetch
-              // of segments since `syncAll` was already executed when starting the main client
-              producer.synchronizeMySegments();
-            }
-          }
-          pushManager.startNewClient(userKey, context);
-        } else {
-          producer.start();
-        }
-      },
-
-      stop() {
-        const context = contexts[userKey];
-
-        if (context) { // check in case `client.destroy()` has been invoked more than once for the same client
-          delete contexts[userKey];
-
-          if (pushManager) {
-            pushManager.removeClient(userKey);
-            // stop push if stoping main client
-            if (!isSharedClient)
-              pushManager.stop();
-            // We don't reconnect pushmanager when removing a shared client,
-            // since it is more costly than continue listening the channel
-          }
-
-          if (producer.isRunning())
-            producer.stop();
-
-        }
-      }
-    };
-  }
-
-  // For the main client we return a SyncManager with 3 methods: start, stop and shared. The last is used to instantiate "partial SyncManagers".
-  syncManager.shared = createInstance.bind(null, true);
-  // pushManager is exposed to close SSE connection in browser on 'unload' DOM event.
-  syncManager.pushManager = pushManager;
-
-  return syncManager;
-}

package/src/sync/constants.js

@@ -1,43 +0,0 @@
-// time for refresh token
-export const SECONDS_BEFORE_EXPIRATION = 600;
-
-// Internal SDK events, subscribed by SyncManager and PushManager
-/**
- * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
- * triggers `handleNonRetryableError` call
- */
-export const PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
-/**
- * emitted on SSE and Authenticate recoverable errors
- * triggers `handleRetryableError` call
- */
-export const PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
-/**
- * emitted on STREAMING_RESUMED control notification, OCCUPANCY different than 0, and SSE onopen event
- * triggers `stopPollingAndSyncAll` call
- */
-export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
-
-/**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
- * triggers `startPolling` and `stopWorkers` calls
- */
-export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
-
-// Update-type push notifications, handled by NotificationProcessor
-export const MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export const MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
-export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
-export const SPLIT_KILL = 'SPLIT_KILL';
-export const SPLIT_UPDATE = 'SPLIT_UPDATE';
-
-// Control-type push notifications, handled by NotificationKeeper
-export const CONTROL = 'CONTROL';
-export const OCCUPANCY = 'OCCUPANCY';
-
-export const ControlTypes = {
-  STREAMING_DISABLED: 'STREAMING_DISABLED',
-  STREAMING_PAUSED: 'STREAMING_PAUSED',
-  STREAMING_RESUMED: 'STREAMING_RESUMED',
-  STREAMING_RESET: 'STREAMING_RESET'
-};

package/src/sync/node.js

@@ -1,66 +0,0 @@
-import PushManagerFactory from './PushManager';
-import FullProducerFactory from '../producer';
-import logFactory from '../utils/logger';
-import { PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP } from './constants';
-const log = logFactory('splitio-sync:sync-manager');
-
-/**
- * Factory of SyncManager for node
- *
- * @param context main client context
- */
-export default function NodeSyncManagerFactory(context) {
-
-  const producer = FullProducerFactory(context);
-  const settings = context.get(context.constants.SETTINGS);
-
-  // add producer into the context before creating the PushManager
-  context.put(context.constants.PRODUCER, producer);
-  const pushManager = settings.streamingEnabled ? PushManagerFactory(context) : undefined;
-
-  function startPolling() {
-    if (!producer.isRunning()) {
-      log.info('Streaming not available. Starting periodic fetch of data.');
-      producer.start();
-    } else {
-      log.info('Streaming couldn\'t connect. Continue periodic fetch of data.');
-    }
-  }
-
-  function stopPollingAndSyncAll() {
-    log.info('PUSH (re)connected. Syncing and stopping periodic fetch of data.');
-    // if polling, stop
-    if (producer.isRunning())
-      producer.stop();
-    syncAll();
-  }
-
-  function syncAll() {
-    // fetch splits and segments. There is no need to catch this promise (it is handled by `SplitChangesUpdater`)
-    producer.synchronizeSplits().then(() => {
-      producer.synchronizeSegment();
-    });
-  }
-
-  return {
-    start() {
-      // start syncing
-      if (pushManager) {
-        syncAll();
-        pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-        pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
-        setTimeout(pushManager.start); // Run in next event-loop cycle as in browser
-      } else {
-        producer.start();
-      }
-    },
-    stop() {
-      // stop syncing
-      if (pushManager)
-        pushManager.stop();
-
-      if (producer.isRunning())
-        producer.stop();
-    }
-  };
-}

package/src/sync/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "./node.js",
-  "browser": "./browser.js"
-}

package/src/trackers/event.js

@@ -1,47 +0,0 @@
-import objectAssign from 'object-assign';
-import logFactory from '../utils/logger';
-import thenable from '../utils/promise/thenable';
-const log = logFactory('splitio-client:event-tracker');
-
-function EventTracker(context) {
-  const collector = context.get(context.constants.STORAGE).events;
-  const integrationsManager = context.get(context.constants.INTEGRATIONS_MANAGER, true);
-
-  function queueEventsCallback(eventData, tracked) {
-    const { eventTypeId, trafficTypeName, key, value, timestamp, properties } = eventData;
-    // Logging every prop would be too much.
-    const msg = `event of type "${eventTypeId}" for traffic type "${trafficTypeName}". Key: ${key}. Value: ${value}. Timestamp: ${timestamp}. ${properties ? 'With properties.' : 'With no properties.'}`;
-
-    if (tracked) {
-      log.info(`Successfully queued ${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
-          const eventDataCopy = objectAssign({}, eventData);
-          if (eventData.properties) eventDataCopy.properties = objectAssign({}, eventData.properties);
-          // integrationsManager does not throw errors (they are internally handled by each integration module)
-          integrationsManager.handleEvent(eventDataCopy);
-        }, 0);
-      }
-    } else {
-      log.warn(`Failed to queue ${msg}`);
-    }
-
-    return tracked;
-  }
-
-  return {
-    track: function (eventData, size) {
-      const tracked = collector.track(eventData, size);
-
-      if (thenable(tracked)) {
-        return tracked.then(queueEventsCallback.bind(null, eventData));
-      } else {
-        return queueEventsCallback(eventData, tracked);
-      }
-    }
-  };
-}
-
-export default EventTracker;