mixpanel-react-native 2.4.1 → 3.0.0-beta.2

package/javascript/mixpanel-config.js

@@ -0,0 +1,102 @@
+import {
+  defaultBatchSize,
+  defaultFlushInterval,
+  defaultServerURL,
+} from "./mixpanel-constants";
+
+import {MixpanelLogger} from "./mixpanel-logger";
+
+export class MixpanelConfig {
+  static instance;
+
+  static getInstance() {
+    if (!MixpanelConfig.instance) {
+      MixpanelConfig.instance = new MixpanelConfig();
+    }
+    return MixpanelConfig.instance;
+  }
+
+  constructor() {
+    if (MixpanelConfig.instance) {
+      throw new Error(`Use MixpanelConfig.getInstance()`);
+    }
+    this._config = {};
+  }
+
+  setLoggingEnabled(token, loggingEnabled) {
+    this._config[token] = {
+      ...this._config[token],
+      loggingEnabled,
+    };
+    if (loggingEnabled) {
+      console.info(`Mixpanel Logging Enabled`);
+    } else {
+      console.info(`Mixpanel Logging Disabled`);
+    }
+  }
+
+  getLoggingEnabled(token) {
+    return (this._config[token] && this._config[token].loggingEnabled) || false;
+  }
+
+  setServerURL(token, serverURL) {
+    this._config[token] = {
+      ...this._config[token],
+      serverURL,
+    };
+    MixpanelLogger.log(token, `Set serverURL: ${serverURL}`);
+  }
+
+  getServerURL(token) {
+    return (
+      (this._config[token] && this._config[token].serverURL) || defaultServerURL
+    );
+  }
+
+  setUseIpAddressForGeolocation(token, useIpAddressForGeolocation) {
+    this._config[token] = {
+      ...this._config[token],
+      useIpAddressForGeolocation,
+    };
+    MixpanelLogger.log(
+      token,
+      `Set useIpAddressForGeolocation: ${useIpAddressForGeolocation}`
+    );
+  }
+
+  getUseIpAddressForGeolocation(token) {
+    return (
+      (this._config[token] && this._config[token].useIpAddressForGeolocation) ||
+      true
+    );
+  }
+
+  setFlushBatchSize(token, batchSize) {
+    this._config[token] = {
+      ...this._config[token],
+      batchSize,
+    };
+    MixpanelLogger.log(token, `Set flush batch size: ${batchSize}`);
+  }
+
+  getFlushBatchSize(token) {
+    return (
+      (this._config[token] && this._config[token].batchSize) || defaultBatchSize
+    );
+  }
+
+  setFlushInterval(token, flushInterval) {
+    this._config[token] = {
+      ...this._config[token],
+      flushInterval,
+    };
+    MixpanelLogger.log(token, `Set flush interval: ${flushInterval}`);
+  }
+
+  getFlushInterval(token) {
+    return (
+      (this._config[token] && this._config[token].flushInterval) ||
+      defaultFlushInterval
+    );
+  }
+}

package/javascript/mixpanel-constants.js

@@ -0,0 +1,22 @@
+export const MixpanelType = {
+  EVENTS: "/track/",
+  USER: "/engage/",
+  GROUPS: "/groups/",
+};
+
+export const getQueueKey = (token, type) => `MIXPANEL_${token}_${type}_QUEUE`;
+
+export const getDeviceIdKey = (token) => `MIXPANEL_${token}_DEVICE_ID`;
+export const getDistinctIdKey = (token) => `MIXPANEL_${token}_DISTINCT_ID`;
+export const getUserIdKey = (token) => `MIXPANEL_${token}_USER_ID`;
+
+export const getOptedOutKey = (token) => `MIXPANEL_${token}_OPT_OUT`;
+export const getSuperPropertiesKey = (token) =>
+  `MIXPANEL_${token}_SUPER_PROPERTIES`;
+export const getTimeEventsKey = (token) => `MIXPANEL_${token}_TIME_EVENTS`;
+export const getAppHasOpenedBeforeKey = (token) =>
+  `MIXPANEL_${token}_APP_HAS_OPENED_BEFORE`;
+
+export const defaultServerURL = `https://api.mixpanel.com`;
+export const defaultBatchSize = 50;
+export const defaultFlushInterval = 10 * 1000; // 10s

package/javascript/mixpanel-core.js

@@ -0,0 +1,163 @@
+import {MixpanelQueueManager} from "./mixpanel-queue";
+import {MixpanelNetwork} from "./mixpanel-network";
+import {SessionMetadata} from "./mixpanel-utils";
+import {MixpanelType} from "./mixpanel-constants";
+import {MixpanelConfig} from "./mixpanel-config";
+import {MixpanelPersistent} from "./mixpanel-persistent";
+import {MixpanelLogger} from "./mixpanel-logger";
+
+export const MixpanelCore = (storage) => {
+  const mixpanelPersistent = MixpanelPersistent.getInstance(storage);
+  const config = MixpanelConfig.getInstance();
+  let isProcessingQueue = false;
+  let processQueueInterval = null;
+
+  const initialize = async (token) => {
+    await MixpanelQueueManager.initialize(token, MixpanelType.EVENTS);
+  };
+
+  const startProcessingQueue = (token) => {
+    if (mixpanelPersistent.getOptedOut(token)) {
+      MixpanelLogger.log(
+        token,
+        `User has opted out of tracking, skipping processing queue.`
+      );
+      return;
+    }
+
+    if (isProcessingQueue) {
+      MixpanelLogger.log(
+        token,
+        `Queue is already being processed. Skipping new cycle.`
+      );
+      return;
+    }
+
+    isProcessingQueue = true;
+
+    processQueueInterval = setInterval(async () => {
+      clearInterval(processQueueInterval);
+      await processQueue(token, MixpanelType.EVENTS);
+      await processQueue(token, MixpanelType.USER);
+      await processQueue(token, MixpanelType.GROUPS);
+
+      isProcessingQueue = false;
+      startProcessingQueue(token);
+    }, config.getFlushInterval(token));
+  };
+
+  const isValidAndSerializable = (token, obj, depth = 1) => {
+    try {
+      JSON.stringify(obj);
+    } catch (error) {
+      MixpanelLogger.error(token, `Error in Mixpanel payload: ${error}`);
+      return false;
+    }
+    return true;
+  };
+
+  const addToMixpanelQueue = async (token, type, data) => {
+    if (mixpanelPersistent.getOptedOut(token)) {
+      MixpanelLogger.log(
+        token,
+        `User has opted out of tracking, skipping tracking.`
+      );
+      return;
+    }
+    if (!isValidAndSerializable(token, data)) {
+      MixpanelLogger.error(
+        token,
+        `The Mixpanel payload is not valid or not serializable.`
+      );
+      return;
+    }
+    const sessionMetadata = new SessionMetadata();
+    await MixpanelQueueManager.enqueue(token, type, {
+      ...sessionMetadata.toDict(type),
+      ...data,
+    });
+    MixpanelLogger.log(
+      token,
+      `The mixpanel payload is added to the Mixpanel queue. Payload: '${JSON.stringify(
+        {
+          ...sessionMetadata.toDict(type),
+          ...data,
+        }
+      )}' Type: '${type}' `
+    );
+  };
+
+  const flush = async (token) => {
+    if (mixpanelPersistent.getOptedOut(token)) {
+      MixpanelLogger.log(
+        token,
+        `User has opted out of tracking, do not flush queue.`
+      );
+      return;
+    }
+    await processQueue(token, MixpanelType.EVENTS);
+    await processQueue(token, MixpanelType.USER);
+    await processQueue(token, MixpanelType.GROUPS);
+  };
+
+  const processQueue = async (token, type) => {
+    MixpanelLogger.log(token, `Processing queue for endpoint: ${type}`);
+    const processBatch = async () => {
+      const queue = MixpanelQueueManager.getQueue(token, type);
+      if (queue.length > 0) {
+        MixpanelLogger.log(token, `[Flushing queue] endpoint: ${type}`);
+        MixpanelLogger.log(
+          token,
+          `[Flushing queue] queue: ${JSON.stringify(queue)}`
+        );
+        const batchSize = config.getFlushBatchSize(token);
+        const batch = queue.slice(0, batchSize);
+        try {
+          await MixpanelNetwork.sendRequest({
+            token,
+            data: batch,
+            endpoint: type,
+            serverURL: config.getServerURL(token),
+            useIPAddressForGeoLocation:
+              config.getUseIpAddressForGeolocation(token),
+          });
+          await MixpanelQueueManager.spliceQueue(token, type, 0, batch.length);
+          // Process the next batch if there are more events in the queue
+          const queue = MixpanelQueueManager.getQueue(token, type);
+          if (queue.length > 0) {
+            setTimeout(processBatch, 0);
+          }
+        } catch (error) {
+          handleBatchError(token, error, type, processBatch);
+        }
+      }
+    };
+
+    processBatch();
+  };
+
+  const handleBatchError = (token, error, type, callback) => {
+    if (error.code === 400) {
+      MixpanelLogger.error(
+        token,
+        `Bad request received due to corrupted data within the batch. The corrupted data is now being removed from the queue...`
+      );
+      // Remove the corrupted data from the queue, to avoid the data loss, only remove one event at a time
+      MixpanelQueueManager.spliceQueue(token, type, 0, 1).then(() => {
+        setTimeout(callback, 0);
+      });
+    } else {
+      MixpanelLogger.error(
+        token,
+        `Error sending event batch from queue, error: ${error}`
+      );
+    }
+  };
+
+  return {
+    initialize,
+    startProcessingQueue,
+    addToMixpanelQueue,
+    flush,
+  };
+};

package/javascript/mixpanel-logger.js

@@ -0,0 +1,35 @@
+import {MixpanelConfig} from "mixpanel-react-native/javascript/mixpanel-config";
+
+export class MixpanelLogger {
+  static _shouldLog(token) {
+    return MixpanelConfig.getInstance().getLoggingEnabled(token);
+  }
+
+  static _prependPrefix(args) {
+    return ["[Mixpanel]", ...args];
+  }
+
+  static log(token, ...args) {
+    if (MixpanelLogger._shouldLog(token)) {
+      console.log(...MixpanelLogger._prependPrefix(args));
+    }
+  }
+
+  static info(token, ...args) {
+    if (MixpanelLogger._shouldLog(token)) {
+      console.info(...MixpanelLogger._prependPrefix(args));
+    }
+  }
+
+  static warn(token, ...args) {
+    if (MixpanelLogger._shouldLog(token)) {
+      console.warn(...MixpanelLogger._prependPrefix(args));
+    }
+  }
+
+  static error(token, ...args) {
+    if (MixpanelLogger._shouldLog(token)) {
+      console.error(...MixpanelLogger._prependPrefix(args));
+    }
+  }
+}