@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/src/sync/SSEHandler/index.js

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,73 @@
+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

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

package/src/sync/SplitUpdateWorker/index.js

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,43 @@
+// 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

@@ -0,0 +1,66 @@
+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

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

package/src/trackers/event.js

@@ -0,0 +1,47 @@
+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;