iureiure 1.0.0

package/packages/analytics-js-integrations/src/integrations/BingAds/utils.js

@@ -0,0 +1,100 @@
+const EXCLUSION_KEYS = [
+  'event',
+  'category',
+  'category_id',
+  'currency',
+  'total',
+  'value',
+  'revenue',
+  'ecomm_category',
+  'transaction_id',
+  'order_id',
+  'checkout_id',
+  'ecomm_pagetype',
+  'pagetype',
+  'query',
+  'products',
+  'product_id',
+  'sku',
+  'event_action',
+  'items',
+];
+
+const DEFAULT_PAGETYPE = 'other';
+
+const buildCommonPayload = message => {
+  const { event, properties = {} } = message;
+  const { category, currency, total, value, revenue } = properties;
+  const payload = {
+    event_label: event,
+    event_category: category,
+    currency,
+    revenue_value: total || value || revenue,
+  };
+  return payload;
+};
+
+const handleProductsArray = properties => {
+  const productIds = [];
+  const items = [];
+
+  const products = Array.isArray(properties.products) ? properties.products : [properties];
+
+  products.forEach(product => {
+    const { product_id: pId, sku, price, quantity = 1 } = product;
+    const productId = pId || sku;
+
+    if (productId) {
+      productIds.push(productId);
+      const item = { id: productId, quantity };
+      if (price && !Number.isNaN(price)) {
+        item.price = price;
+      }
+      items.push(item);
+    }
+  });
+
+  const payload = {};
+  if (items.length > 0) {
+    payload.ecomm_prodid = productIds;
+    payload.items = items;
+  }
+
+  return payload;
+};
+
+const buildEcommPayload = message => {
+  const { properties = {} } = message;
+  const {
+    category_id: categoryId,
+    total,
+    value,
+    ecomm_category: ecommCategory,
+    transaction_id: transactionId,
+    order_id: orderId,
+    checkout_id: checkoutId,
+    ecomm_pagetype: ecommPageType,
+    pagetype,
+    query,
+  } = properties;
+
+  const ecommPayload = {
+    ecomm_totalvalue: total || value,
+    search_term: query,
+    ecomm_query: query,
+    ecomm_category: ecommCategory || categoryId,
+    transaction_id: transactionId || orderId || checkoutId,
+    ecomm_pagetype: ecommPageType || pagetype || DEFAULT_PAGETYPE,
+  };
+  const payload = handleProductsArray(properties);
+
+  return { ...ecommPayload, ...payload };
+};
+
+export {
+  buildCommonPayload,
+  buildEcommPayload,
+  handleProductsArray,
+  EXCLUSION_KEYS,
+  DEFAULT_PAGETYPE,
+};

package/packages/analytics-js-integrations/src/integrations/Braze/browser.js

@@ -0,0 +1,297 @@
+/* eslint-disable class-methods-use-this */
+import isEqual from 'lodash.isequal';
+import { isEmpty } from 'ramda';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Braze/constants';
+import { Storage } from '@rudderstack/analytics-js-common/v1.1/utils/storage';
+import { stringifyWithoutCircularV1 } from '@rudderstack/analytics-js-common/v1.1/utils/ObjectUtils';
+import Logger from '../../utils/logger';
+import { isObject } from '../../utils/utils';
+import { handlePurchase, formatGender, handleReservedProperties } from './utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+/*
+E-commerce support required for logPurchase support & other e-commerce events as track with productId changed
+*/
+class Braze {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.appKey = config.appKey;
+    this.trackAnonymousUser = config.trackAnonymousUser;
+    this.enableBrazeLogging = config.enableBrazeLogging || false;
+    this.allowUserSuppliedJavascript = config.allowUserSuppliedJavascript || false;
+    this.enablePushNotification = config.enablePushNotification || false;
+    if (!config.appKey) this.appKey = '';
+    this.endPoint = '';
+    this.isHybridModeEnabled = config.connectionMode === 'hybrid';
+    if (config.dataCenter) {
+      // ref: https://www.braze.com/docs/user_guide/administrative/access_braze/braze_instances
+      const dataCenterArr = config.dataCenter.trim().split('-');
+      if (dataCenterArr[0].toLowerCase() === 'eu') {
+        this.endPoint = `sdk.fra-${dataCenterArr[1]}.braze.eu`;
+      } else {
+        this.endPoint = `sdk.iad-${dataCenterArr[1]}.braze.com`;
+      }
+    }
+
+    this.name = NAME;
+    this.supportDedup = config.supportDedup || false;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk();
+    window.braze.initialize(this.appKey, {
+      enableLogging: this.enableBrazeLogging,
+      baseUrl: this.endPoint,
+      allowUserSuppliedJavascript: this.allowUserSuppliedJavascript,
+    });
+    window.braze.automaticallyShowInAppMessages();
+    const { userId } = this.analytics;
+    // send userId if you have it https://js.appboycdn.com/web-sdk/latest/doc/module-appboy.html#.changeUser
+    if (userId) {
+      window.braze.changeUser(userId);
+    }
+    if (this.enablePushNotification) {
+      window.braze.requestPushPermission();
+    }
+    window.braze.openSession();
+  }
+
+  isLoaded() {
+    return window.brazeQueue === null;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  /**
+   * As each users will have unique session, So if the supportDedup is enabled from config,
+   * then we are comparing from the previous payload and tried to reduce the redundant data.
+   * If supportDedup is enabled,
+   * Examples:
+   * - If userId is different from previous call, then it will make new call and store the payload.
+   * - It will deeply check all other attributes and pass the unique or changed fields.
+   *   1st- payload                                                                                     2nd- payload
+   * rudderanalytics.identify("rudderUserId100", {                                                   rudderanalytics.identify("rudderUserId100", {
+   *  name: "Rudder Keener",                                                                          name: "Rudder Keener",
+   *  email: "rudder100@example.com",                                                                 email: "rudder100@example.com",
+   *  primaryEmail: "test350@email.com",                                                              primaryEmail: "test350@email.com",
+   *  country: "USA",                                                                                 country: "USA",
+   *  subscription: "youtube-prime-6",                                                                subscription: "youtube-prime-6",
+   *  channelName: ["b", "d", "e", "f"],                                                              channelName: ["b", "d", "e", "f"],
+   *  gender: "male",                                                                                 gender: "male",
+   *  facebook: "https://www.facebook.com/rudder.123",                                                facebook: "https://www.facebook.com/rudder.345",
+   *  birthday: new Date("2000-10-23"),                                                               birthday: new Date("2000-10-24"),
+   *  firstname: "Rudder",                                                                            firstname: "Rudder",
+   *  lastname: "Keener",                                                                             lastname: "Usertest",
+   *  phone: "9112345631",                                                                            phone: "9112345631",
+   *  key1: "value4",                                                                                 key1: "value5",
+   *  address: {                                                                                      address: {
+   *   city: "Manali",                                                                                 city: "Shimla",
+   *   country: "India",                                                                               country: "India",
+   *  },                                                                                              },
+   * });                                                                                             });
+   * As both payload have same userId so it will deeply check all other attributes and pass the unique fields
+   * or the updated fields.
+   * @param {*} rudderElement
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  identify(rudderElement) {
+    if (this.isHybridModeEnabled) {
+      return;
+    }
+
+    const { message } = rudderElement;
+    const { userId } = message;
+    const { context } = message;
+    const email = context?.traits?.email;
+    const firstName = context?.traits?.firstName || context?.traits?.firstname;
+    const lastName = context?.traits?.lastName || context?.traits?.lastname;
+    const gender = context?.traits?.gender;
+    const phone = context?.traits?.phone;
+    const address = context?.traits?.address;
+    const birthday = context?.traits?.birthday || context?.traits?.dob;
+    const reserved = [
+      'address',
+      'birthday',
+      'email',
+      'id',
+      'firstname',
+      'firstName',
+      'gender',
+      'lastname',
+      'lastName',
+      'phone',
+      'dob',
+      'birthday',
+      'external_id',
+      'country',
+      'home_city',
+      'email_subscribe',
+      'push_subscribe',
+    ];
+    // function set Address
+    function setAddress() {
+      window.braze.getUser().setCountry(address?.country);
+      window.braze.getUser().setHomeCity(address?.city);
+    }
+    // function set Birthday
+    function setBirthday() {
+      try {
+        const date = new Date(birthday);
+        if (date.toString() === 'Invalid Date') {
+          logger.error('Invalid Date for birthday');
+          return;
+        }
+        window.braze
+          .getUser()
+          .setDateOfBirth(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+      } catch (error) {
+        logger.error(`Error in setting birthday - ${stringifyWithoutCircularV1(error, true)}`);
+      }
+    }
+    // function set Email
+    function setEmail() {
+      window.braze.getUser().setEmail(email);
+    }
+    // function set firstName
+    function setFirstName() {
+      window.braze.getUser().setFirstName(firstName);
+    }
+    // function set gender
+    function setGender(genderName) {
+      window.braze.getUser().setGender(genderName);
+    }
+    // function set lastName
+    function setLastName() {
+      window.braze.getUser().setLastName(lastName);
+    }
+    function setPhone() {
+      window.braze.getUser().setPhoneNumber(phone);
+    }
+
+    // eslint-disable-next-line unicorn/consistent-destructuring
+    const traits = message?.context?.traits;
+
+    const previousPayload = Storage.getItem('rs_braze_dedup_attributes') || {};
+    if (this.supportDedup && !isEmpty(previousPayload) && userId === previousPayload?.userId) {
+      const prevTraits = previousPayload?.context?.traits;
+      const prevAddress = prevTraits?.address;
+      const prevBirthday = prevTraits?.birthday || prevTraits?.dob;
+      const prevEmail = prevTraits?.email;
+      const prevFirstname = prevTraits?.firstname || prevTraits?.firstName;
+      const prevGender = prevTraits?.gender;
+      const prevLastname = prevTraits?.lastname || prevTraits?.lastName;
+      const prevPhone = prevTraits?.phone;
+
+      if (email && email !== prevEmail) setEmail();
+      if (phone && phone !== prevPhone) setPhone();
+      if (birthday && !isEqual(birthday, prevBirthday)) setBirthday();
+      if (firstName && firstName !== prevFirstname) setFirstName();
+      if (lastName && lastName !== prevLastname) setLastName();
+      if (gender && formatGender(gender) !== formatGender(prevGender))
+        setGender(formatGender(gender));
+      if (address && !isEqual(address, prevAddress)) setAddress();
+      if (isObject(traits)) {
+        Object.keys(traits)
+          .filter(key => reserved.indexOf(key) === -1)
+          .forEach(key => {
+            if (!prevTraits[key] || !isEqual(prevTraits[key], traits[key])) {
+              window.braze.getUser().setCustomUserAttribute(key, traits[key]);
+            }
+          });
+      }
+    } else {
+      window.braze.changeUser(userId);
+      // method removed from v4 https://www.braze.com/docs/api/objects_filters/user_attributes_object#braze-user-profile-fields
+      // window.braze.getUser().setAvatarImageUrl(avatar);
+      if (email) setEmail();
+      if (firstName) setFirstName();
+      if (lastName) setLastName();
+      if (gender) setGender(formatGender(gender));
+      if (phone) setPhone();
+      if (address) setAddress();
+      if (birthday) setBirthday();
+
+      if (isObject(traits)) {
+        Object.keys(traits)
+          .filter(key => reserved.indexOf(key) === -1)
+          .forEach(key => {
+            window.braze.getUser().setCustomUserAttribute(key, traits[key]);
+          });
+      }
+    }
+    if (
+      this.supportDedup &&
+      isObject(previousPayload) &&
+      !isEmpty(previousPayload) &&
+      userId === previousPayload?.userId
+    ) {
+      Storage.setItem('rs_braze_dedup_attributes', { ...previousPayload, ...message });
+    } else if (this.supportDedup) {
+      Storage.setItem('rs_braze_dedup_attributes', message);
+    }
+  }
+
+  track(rudderElement) {
+    if (this.isHybridModeEnabled) {
+      return;
+    }
+    const { userId } = rudderElement.message;
+    const eventName = rudderElement.message.event;
+    let { properties } = rudderElement.message;
+    const { anonymousId } = rudderElement.message;
+    let canSendCustomEvent = false;
+    if (userId) {
+      window.braze.changeUser(userId);
+      canSendCustomEvent = true;
+    } else if (this.trackAnonymousUser) {
+      window.braze.changeUser(anonymousId);
+      canSendCustomEvent = true;
+    }
+    if (eventName && canSendCustomEvent) {
+      if (eventName.toLowerCase() === 'order completed') {
+        handlePurchase(properties, userId);
+      } else {
+        properties = handleReservedProperties(properties);
+        window.braze.logCustomEvent(eventName, properties);
+      }
+    }
+  }
+
+  page(rudderElement) {
+    if (this.isHybridModeEnabled) {
+      return;
+    }
+    const { userId } = rudderElement.message;
+    const eventName = rudderElement.message.name;
+    let { properties } = rudderElement.message;
+    const { anonymousId } = rudderElement.message;
+    if (userId) {
+      window.braze.changeUser(userId);
+    } else if (this.trackAnonymousUser) {
+      window.braze.changeUser(anonymousId);
+    }
+    properties = handleReservedProperties(properties);
+    if (eventName) {
+      window.braze.logCustomEvent(eventName, properties);
+    } else {
+      window.braze.logCustomEvent('Page View', properties);
+    }
+  }
+}
+
+export default Braze;

package/packages/analytics-js-integrations/src/integrations/Braze/index.js

@@ -0,0 +1 @@
+export { default as Braze } from './browser';

package/packages/analytics-js-integrations/src/integrations/Braze/nativeSdkLoader.js

@@ -0,0 +1,35 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import { BrazeOperationString } from '@rudderstack/analytics-js-common/constants/integrations/Braze/constants';
+
+const loadNativeSdk = () => {
+  // load braze
+  +(function (a, p, P, b, y) {
+    a.braze = {};
+    a.brazeQueue = [];
+    for (let s = BrazeOperationString.split(' '), i = 0; i < s.length; i++) {
+      for (var m = s[i], k = a.braze, l = m.split('.'), j = 0; j < l.length - 1; j++) k = k[l[j]];
+      k[l[j]] = new Function(
+        `return function ${m.replace(
+          /\./g,
+          '_',
+        )}(){window.brazeQueue.push(arguments); return true}`,
+      )();
+    }
+    window.braze.getCachedContentCards = function () {
+      return new window.braze.ContentCards();
+    };
+    window.braze.getCachedFeed = function () {
+      return new window.braze.Feed();
+    };
+    window.braze.getUser = function () {
+      return new window.braze.User();
+    };
+    (y = p.createElement(P)).type = 'text/javascript';
+    y.src = 'https://js.appboycdn.com/web-sdk/5.0/braze.min.js';
+    y.async = 1;
+    y.setAttribute('data-loader', LOAD_ORIGIN);
+    (b = p.getElementsByTagName(P)[0]).parentNode.insertBefore(y, b);
+  })(window, document, 'script');
+};
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/Braze/utils.js

@@ -0,0 +1,51 @@
+import { del } from 'obj-case';
+
+/** https://js.appboycdn.com/web-sdk/latest/doc/ab.User.html#toc4
+ */
+const formatGender = gender => {
+  if (typeof gender !== 'string') return undefined;
+  const femaleGenders = ['woman', 'female', 'w', 'f'];
+  const maleGenders = ['man', 'male', 'm'];
+  const otherGenders = ['other', 'o'];
+
+  if (femaleGenders.indexOf(gender.toLowerCase()) > -1) return window.braze.User.Genders.FEMALE;
+  if (maleGenders.includes(gender.toLowerCase()) > -1) return window.braze.User.Genders.MALE;
+  if (otherGenders.includes(gender.toLowerCase()) > -1) return window.braze.User.Genders.OTHER;
+  return undefined;
+};
+
+const handleReservedProperties = props => {
+  // remove reserved keys from custom event properties
+  // https://www.appboy.com/documentation/Platform_Wide/#reserved-keys
+  const reserved = ['time', 'product_id', 'quantity', 'event_name', 'price', 'currency'];
+
+  reserved.forEach(element => {
+    // eslint-disable-next-line no-param-reassign
+    delete props[element];
+  });
+  return props;
+};
+
+const handlePurchase = (properties, userId) => {
+  const { products, currency } = properties;
+  const currencyCode = currency;
+
+  window.braze.changeUser(userId);
+
+  // del used properties
+  del(properties, 'products');
+  del(properties, 'currency');
+
+  // we have to make a separate call to appboy for each product
+  if (products && Array.isArray(products) && products.length > 0) {
+    products.forEach(product => {
+      const productId = product.product_id;
+      const { price } = product;
+      const { quantity } = product;
+      if (quantity && price && productId)
+        window.braze.logPurchase(productId, price, currencyCode, quantity, properties);
+    });
+  }
+};
+
+export { formatGender, handleReservedProperties, handlePurchase };

package/packages/analytics-js-integrations/src/integrations/Bugsnag/browser.js

@@ -0,0 +1,62 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Bugsnag/constants';
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import Logger from '../../utils/logger';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Bugsnag {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.releaseStage = config.releaseStage;
+    this.apiKey = config.apiKey;
+    this.name = NAME;
+    this.setIntervalHandler = undefined;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    ScriptLoader('bugsnag-id', 'https://d2wy8f7a9ursnm.cloudfront.net/v6/bugsnag.min.js');
+
+    this.setIntervalHandler = setInterval(this.initBugsnagClient.bind(this), 1000);
+  }
+
+  initBugsnagClient() {
+    if (window.bugsnag !== undefined) {
+      window.bugsnagClient = window.bugsnag(this.apiKey);
+      window.bugsnagClient.releaseStage = this.releaseStage;
+      clearInterval(this.setIntervalHandler);
+    }
+  }
+
+  isLoaded() {
+    return !!window.bugsnagClient;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { traits } = rudderElement.message.context;
+    const traitsFinal = {
+      id: rudderElement.message.userId || rudderElement.message.anonymousId,
+      name: traits.name,
+      email: traits.email,
+    };
+
+    window.bugsnagClient.user = traitsFinal;
+    window.bugsnagClient.notify(new Error('error in identify'));
+  }
+}
+export default Bugsnag;

package/packages/analytics-js-integrations/src/integrations/Bugsnag/index.js

@@ -0,0 +1 @@
+export { default as Bugsnag } from './browser';

package/packages/analytics-js-integrations/src/integrations/Chartbeat/browser.js

@@ -0,0 +1,143 @@
+/* eslint-disable compat/compat */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import onBody from 'on-body';
+import {
+  MAX_WAIT_FOR_INTEGRATION_LOAD,
+  INTEGRATION_LOAD_CHECK_INTERVAL,
+} from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Chartbeat/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Chartbeat {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics; // use this to modify failed integrations or for passing events from callback to other destinations
+    window._sf_async_config = window._sf_async_config || {};
+    window._sf_async_config.useCanonical = true;
+    window._sf_async_config.uid = config.uid;
+    window._sf_async_config.domain = config.domain;
+    this._sf_async_config = window._sf_async_config;
+    this.isVideo = !!config.video;
+    this.sendNameAndCategoryAsTitle = config.sendNameAndCategoryAsTitle || true;
+    this.subscriberEngagementKeys = config.subscriberEngagementKeys || [];
+    this.replayEvents = [];
+    this.failed = false;
+    this.isFirstPageCallMade = false;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {}
+
+  isLoaded() {
+    if (!this.isFirstPageCallMade) {
+      return true;
+    }
+    return !!window.pSUPERFLY;
+  }
+
+  isFailed() {
+    return this.failed;
+  }
+
+  isReady() {
+    return !!window.pSUPERFLY;
+  }
+
+  page(rudderElement) {
+    this.loadConfig(rudderElement);
+
+    if (!this.isFirstPageCallMade) {
+      this.isFirstPageCallMade = true;
+      this.initAfterPage();
+    } else {
+      if (this.failed) {
+        this.replayEvents = [];
+        return;
+      }
+      if (!this.isLoaded() && !this.failed) {
+        this.replayEvents.push(['page', rudderElement]);
+        return;
+      }
+      const { properties } = rudderElement.message;
+      window.pSUPERFLY.virtualPage(properties.path);
+    }
+  }
+
+  loadConfig(rudderElement) {
+    const { properties } = rudderElement.message;
+    const category = properties ? properties.category : undefined;
+    const { name } = rudderElement.message;
+    const author = properties ? properties.author : undefined;
+    let title;
+    if (this.sendNameAndCategoryAsTitle) {
+      title = category && name ? `${category} ${name}` : name;
+    }
+    if (category) window._sf_async_config.sections = category;
+    if (author) window._sf_async_config.authors = author;
+    if (title) window._sf_async_config.title = title;
+
+    window._cbq = window._cbq || [];
+    const { _cbq: cbq } = window;
+
+    Object.keys(properties)
+      .filter(
+        key =>
+          Object.prototype.hasOwnProperty.call(properties, key) &&
+          this.subscriberEngagementKeys.includes(key),
+      )
+      .forEach(key => {
+        cbq.push([key, properties[key]]);
+      });
+  }
+
+  initAfterPage() {
+    onBody(() => {
+      const script = this.isVideo ? 'chartbeat_video.js' : 'chartbeat.js';
+      loadNativeSdk(script);
+    });
+
+    this._isReady(this).then(instance => {
+      instance.replayEvents.forEach(event => {
+        instance[event[0]](event[1]);
+      });
+    });
+  }
+
+  pause(time) {
+    return new Promise(resolve => {
+      setTimeout(resolve, time);
+    });
+  }
+
+  _isReady(instance, time = 0) {
+    return new Promise(resolve => {
+      if (this.isLoaded()) {
+        this.failed = false;
+        resolve(instance);
+      }
+      if (time >= MAX_WAIT_FOR_INTEGRATION_LOAD) {
+        this.failed = true;
+        resolve(instance);
+      }
+      this.pause(INTEGRATION_LOAD_CHECK_INTERVAL).then(() =>
+        this._isReady(instance, time + INTEGRATION_LOAD_CHECK_INTERVAL).then(resolve),
+      );
+    });
+  }
+}
+
+export default Chartbeat;