noibu-react-native 0.0.1

package/dist/api/storedMetrics.js

@@ -0,0 +1,201 @@
+import { BROWSER_ID_ATT_NAME, PV_ID_ATT_NAME, COLLECT_VER_ATT_NAME, CURRENT_NOIBUJS_VERSION, VER_ATT_NAME, CURRENT_METRICS_VERSION, EXP_VIDEO_LENGTH_ATT_NAME, PV_EXP_VF_SEQ_ATT_NAME, PV_EXP_PART_COUNTER_ATT_NAME, PV_EXP_HTTP_DATA_SEQ_ATT_NAME, PV_HTTP_PAYLOADS_COLLECTED_ATT_NAME, PV_HTTP_PAYLOADS_DROPPED_OVERSIZE_ATT_NAME, PV_HTTP_PAYLOADS_DROPPED_TYPE_ATT_NAME, PV_HTTP_REQUESTS_DROPPED_OVER_LIMIT, VIDEO_CLICKS_ATT_NAME, PV_CLICKS_ATT_NAME, DID_CUT_PV_ATT_NAME, DID_CUT_VID_ATT_NAME, DID_START_VID_ATT_NAME, HTTP_COUNT_EXPECTED_ATT_NAME, ERR_COUNT_EXPECTED_ATT_NAME, ON_URL_ATT_NAME, GET_METROPLEX_METRICS_URL } from '../constants.js';
+import ClientConfig from './clientConfig.js';
+import { stringifyJSON } from '../utils/function.js';
+import { addSafeEventListener } from '../utils/eventlistener.js';
+
+/** @module StoredMetrics */
+
+/**
+ * This class holds the final page visit and video frag metrics. It flushes
+ * them to local storage and then finally sends them to Metroplex via the post
+ * route when the next page is loaded
+ */
+class StoredMetrics {
+  /**
+   * Creates a new StoredMetrics instance
+   */
+  constructor() {
+    this.expectedVideoLength = 0;
+    this.expectedVfSeq = 0;
+    this.httpSequenceNumber = 0;
+    this.httpOverLimitCount = 0;
+    this.httpDroppedPayloadByTypeCount = 0;
+    this.httpDroppedPayloadByLengthCount = 0;
+    this.httpPayloadCount = 0;
+    this.expectedPvPart = 0;
+    this.videoClicks = 0;
+    this.pvClicks = 0;
+    this.errCount = 0;
+    this.httpCount = 0;
+    this.didCutPv = false;
+    this.didCutVideo = false;
+    this.writeTimeout = null;
+    this.didStartVideo = false;
+
+    this._setupListeners();
+  }
+
+  /** gets the singleton instance */
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new StoredMetrics();
+    }
+
+    return this.instance;
+  }
+
+  /** Add video frag payload data to the stored metrics
+   * @param  {} expectedVfSeq
+   * @param  {} expectedVideoLength
+   */
+  addVideoFragData(expectedVfSeq, expectedVideoLength) {
+    this.expectedVfSeq = expectedVfSeq;
+    this.expectedVideoLength = expectedVideoLength;
+  }
+
+  /** Set the amount of page visit parts
+   * @param  {} expectedPvPart
+   */
+  setPvPart(expectedPvPart) {
+    this.expectedPvPart = expectedPvPart;
+  }
+
+  /** Increase the amount of video clicks seen in the session */
+  addVideoClick() {
+    this.videoClicks += 1;
+  }
+
+  /** Increase the amount of page visit clicks */
+  addPvClick() {
+    this.pvClicks += 1;
+  }
+
+  /** Increments the error count by 1 */
+  addError() {
+    this.errCount += 1;
+  }
+
+  /** Increments the http count by 1 */
+  addHttpEvent() {
+    this.httpCount += 1;
+  }
+
+  /** Increments the http data sequence count by 1 */
+  addHttpData() {
+    this.httpSequenceNumber += 1;
+  }
+
+  /** Increments the http data over limit count by 1 */
+  addHttpDataOverLimit() {
+    this.httpOverLimitCount += 1;
+  }
+
+  /** Increments the http data drop count by content type */
+  addHttpDataDropByType() {
+    this.httpDroppedPayloadByTypeCount += 1;
+  }
+
+  /** Increments the http data drop count by content length */
+  addHttpDataDropByLength() {
+    this.httpDroppedPayloadByLengthCount += 1;
+  }
+
+  /** Increments the http data payload collected count */
+  addHttpDataPayloadCount() {
+    this.httpPayloadCount += 1;
+  }
+
+  /** Set that the video was cut/blocked due to size constraints */
+  setDidCutVideo() {
+    this.didCutVideo = true;
+  }
+
+  /** Set that the video was started */
+  setDidStartVideo() {
+    this.didStartVideo = true;
+  }
+
+  /** Set that the page visit was cut/blocked due to size constraints */
+  setDidCutPv() {
+    this.didCutPv = true;
+  }
+
+  /**
+   * Sets up all the listeners that noibujs should listen to before storing
+   * our metrics to localstorage
+   */
+  _setupListeners() {
+    // Add the window event handlers to post the data to the metrics endpoint
+    const evt = 'pagehide';
+    addSafeEventListener(window, evt, () => {
+      this._postMetricsIfActive(evt);
+    });
+  }
+
+  /** posts the metrics to metroplex if client is active
+   * @param  {} eventName
+   */
+  _postMetricsIfActive(eventName) {
+    if (ClientConfig.getInstance().isClientDisabled) {
+      return;
+    }
+    // Don't send the metrics if the session has become inactive
+    // already sent when went inactive
+    if (ClientConfig.getInstance().isInactive()) {
+      return;
+    }
+    this.postMetrics(eventName);
+  }
+
+  /** posts the metrics to metroplex using the beacon API
+   * @param  {} eventName
+   */
+  postMetrics(eventName) {
+    // Create a new object to write to local storage that doesnt have the timeout and flush members.
+    const lsMetrics = {
+      // metadata
+      [BROWSER_ID_ATT_NAME]: ClientConfig.getInstance().browserId,
+      [PV_ID_ATT_NAME]: ClientConfig.getInstance().pageVisitId,
+      [COLLECT_VER_ATT_NAME]: CURRENT_NOIBUJS_VERSION,
+      [VER_ATT_NAME]: CURRENT_METRICS_VERSION,
+
+      // metrics
+      [EXP_VIDEO_LENGTH_ATT_NAME]: this.expectedVideoLength,
+      [PV_EXP_VF_SEQ_ATT_NAME]: this.expectedVfSeq,
+      [PV_EXP_PART_COUNTER_ATT_NAME]: this.expectedPvPart,
+      [PV_EXP_HTTP_DATA_SEQ_ATT_NAME]: this.httpSequenceNumber,
+      [PV_HTTP_PAYLOADS_COLLECTED_ATT_NAME]: this.httpPayloadCount,
+      [PV_HTTP_PAYLOADS_DROPPED_OVERSIZE_ATT_NAME]:
+        this.httpDroppedPayloadByLengthCount,
+      [PV_HTTP_PAYLOADS_DROPPED_TYPE_ATT_NAME]:
+        this.httpDroppedPayloadByTypeCount,
+      [PV_HTTP_REQUESTS_DROPPED_OVER_LIMIT]: this.httpOverLimitCount,
+      [VIDEO_CLICKS_ATT_NAME]: this.videoClicks,
+      [PV_CLICKS_ATT_NAME]: this.pvClicks,
+      [DID_CUT_PV_ATT_NAME]: this.didCutPv,
+      [DID_CUT_VID_ATT_NAME]: this.didCutVideo,
+      [DID_START_VID_ATT_NAME]: this.didStartVideo,
+      [HTTP_COUNT_EXPECTED_ATT_NAME]: this.httpCount,
+      [ERR_COUNT_EXPECTED_ATT_NAME]: this.errCount,
+      [ON_URL_ATT_NAME]:
+        (global.document &&
+          global.document.location &&
+          global.document.location.href) ||
+        'http://localhost',
+    };
+
+    if (global.fetch) {
+      global.fetch(GET_METROPLEX_METRICS_URL(), {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: stringifyJSON(lsMetrics),
+        // keep alive outlives the current page, its the same as beacon
+        keepalive: true,
+      });
+    }
+  }
+}
+
+export { StoredMetrics as default };

package/dist/api/storedPageVisit.js

@@ -0,0 +1,235 @@
+import { PV_METROPLEX_TYPE, PAGE_VISIT_PART_ATT_NAME, PV_EVENTS_ATT_NAME, TYPE_ATT_NAME, USERSTEP_EVENT_TYPE, ERROR_EVENT_TYPE, LOCATION_EVENT_TYPE, NOIBU_STORED_PAGE_VISIT, SEVERITY_ERROR, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, PAGE_VISIT_INFORMATION_ATT_NAME, PAGE_VISIT_VID_FRAG_ATT_NAME, IS_LAST_ATT_NAME, GET_METROPLEX_POST_URL } from '../constants.js';
+import ClientConfig from './clientConfig.js';
+import { stringifyJSON, makeRequest } from '../utils/function.js';
+import Storage from '../storage/storage.js';
+
+/** @module StoredPageVisit */
+
+/**
+ * This class holds the final page visit. It flushes it to storage and then
+ * finally sends it to Metroplex via the post route when the next page is loaded
+ */
+class StoredPageVisit {
+  /**
+   * Creates a new instance of StoredPageVisit
+   */
+  constructor() {
+    this.latestPageVisitFrag = null;
+    this.writeTimeout = null;
+    this.flushedStorage = false;
+
+    const storage = Storage.getInstance();
+    if (storage.isAvailable()) {
+      this._postPreviousPageVisit();
+    }
+  }
+
+  /** gets the singleton instance */
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new StoredPageVisit();
+    }
+
+    return this.instance;
+  }
+
+  /**
+   * Check if the events contain a click or location change. If they do then write the retry
+   * queue (which contains the metroplex msg sent above) to storage
+   * @param  {} retryMessageQueue
+   * @param  {} pvInfo
+   */
+  checkAndStoreRetryQueue(retryMessageQueue, pvInfo) {
+    // Get the events from the last message
+    const { type, payload } = retryMessageQueue[retryMessageQueue.length - 1];
+
+    // Only store page visit payloads
+    if (type !== PV_METROPLEX_TYPE || !payload[PAGE_VISIT_PART_ATT_NAME]) {
+      return;
+    }
+    const events = payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
+      ? payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
+      : [];
+
+    const filteredEvents = events.filter(
+      event =>
+        // Return true if the event is a userstep, error, or location event
+        // Any userstep is used rather than just mouse clicks because we shouldn't
+        // assume mouse clicks are the only way for any activity to happen
+        event[TYPE_ATT_NAME] === USERSTEP_EVENT_TYPE ||
+        event[TYPE_ATT_NAME] === ERROR_EVENT_TYPE ||
+        event[TYPE_ATT_NAME] === LOCATION_EVENT_TYPE,
+    );
+
+    // Only write the retry queue if it contains a user step or location change
+    if (filteredEvents.length > 0) {
+      this.writePageVisitsFromRetryQueue(retryMessageQueue, pvInfo);
+    }
+  }
+
+  /** Writes the page visit frags in the retry queue to storage
+   * @param  {} retryMessageQueue
+   * @param  {} pvInfo
+   */
+  writePageVisitsFromRetryQueue(retryMessageQueue, pvInfo) {
+    const pageVisitFrags = [];
+    for (let i = 0; i < retryMessageQueue.length; i += 1) {
+      const { type, payload } = retryMessageQueue[i];
+      if (type === PV_METROPLEX_TYPE) {
+        const frag = payload[PAGE_VISIT_PART_ATT_NAME];
+        pageVisitFrags.push(frag);
+      }
+    }
+
+    this._writePageVisitFrags(pageVisitFrags, pvInfo);
+  }
+
+  /** Write the given page visit frags to storage
+   * @param  {} pageVisitFrags
+   * @param  {} pvInfo
+   */
+  _writePageVisitFrags(pageVisitFrags, pvInfo) {
+    // Create a new object to write to storage that doesnt have the timeout and flush members
+    const lsPageVisit = {
+      pageVisitFrags,
+      pageVisitInfo: pvInfo,
+      timestamp: new Date(),
+    };
+
+    const storage = Storage.getInstance();
+
+    const json = stringifyJSON(lsPageVisit);
+
+    try {
+      storage.save(NOIBU_STORED_PAGE_VISIT, json);
+    } catch (err) {
+      storage.remove(NOIBU_STORED_PAGE_VISIT);
+
+      // Calculate current storage size
+      const size = storage.calculateUsedSize();
+
+      ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+        `Error writing pv to storage: ${err}, ` +
+          `json size: ${json.length}, storage size: ${size}, ` +
+          `${storage.getDiagnoseInfo()}`,
+        false,
+        SEVERITY_ERROR,
+      );
+    }
+  }
+
+  /**
+   * Read the stored page visit from storage, create a complete page visit object
+   * and then post that to Metroplex
+   */
+  _getPostData() {
+    const storage = Storage.getInstance();
+
+    // Read the storedPageVisit from storage
+    const data = storage.load(NOIBU_STORED_PAGE_VISIT);
+    if (!data) {
+      return null;
+    }
+
+    let storedPageVisit = {};
+    try {
+      storedPageVisit = JSON.parse(data);
+    } catch (e) {
+      // Remove the item since there is something corrupted
+      storage.remove(NOIBU_STORED_PAGE_VISIT);
+      ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+        `Error parsing page visit string '${data}': ${e}`,
+        false,
+        SEVERITY_ERROR,
+      );
+      return null;
+    }
+
+    // making sure we have the timestamp attribute since we added this logic after initially
+    // releasing the storedPageVisit
+    if (storedPageVisit.timestamp) {
+      // checking how long the page visit was in storage
+      const someTimeAgo = new Date();
+      someTimeAgo.setSeconds(
+        someTimeAgo.getSeconds() - MAX_METROPLEX_SOCKET_INNACTIVE_TIME,
+      );
+
+      // if the user leaves the page for more than 35 minutes, we do not attempt
+      // to send the page visit since we can assume that this will create another pagevisit
+      if (someTimeAgo >= Date.parse(storedPageVisit.timestamp)) {
+        return null;
+      }
+    }
+
+    // Copy the page visit information from storage into a new complete PV
+    const completePv = {
+      [PAGE_VISIT_INFORMATION_ATT_NAME]: storedPageVisit.pageVisitInfo,
+      [PAGE_VISIT_PART_ATT_NAME]: [],
+      [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
+    };
+
+    // Set is last to be true on the page visit information
+    completePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
+
+    // Add the page visit frags to the complete PV
+    for (let i = 0; i < storedPageVisit.pageVisitFrags.length; i += 1) {
+      completePv[PAGE_VISIT_PART_ATT_NAME].push(
+        storedPageVisit.pageVisitFrags[i],
+      );
+    }
+
+    return completePv;
+  }
+
+  /**
+   * Creates and tries to resolve a promise that posts the previous page visit
+   * to Metroplex from storage
+   */
+  _postPreviousPageVisit() {
+    // Whether the post promise resolves or not we need to finally
+    // clear the storage item and set flushed
+    this._getPostPageVisitPromise()
+      .then(() => {
+        this._updateStorageFlushed();
+      })
+      .catch(() => {
+        this._updateStorageFlushed();
+      });
+  }
+
+  /**
+   * Remove the storage item and set flushed to true after they have
+   * been posted to metroplex
+   */
+  _updateStorageFlushed() {
+    this.flushedStorage = true;
+    const storage = Storage.getInstance();
+    storage.remove(NOIBU_STORED_PAGE_VISIT);
+  }
+
+  /** Returns a promise that resolves to post the page visit in storage to Metroplex */
+  _getPostPageVisitPromise() {
+    return new Promise((resolve, reject) => {
+      const data = this._getPostData();
+
+      if (!data) {
+        resolve();
+        return;
+      }
+
+      const headers = {
+        'content-type': 'application/json',
+      };
+
+      makeRequest('POST', GET_METROPLEX_POST_URL(), data, headers, 2000, true)
+        .then(() => {
+          resolve();
+        })
+        .catch(e => {
+          reject(new Error('Page visit post request rejected due to: ', e));
+        });
+    });
+  }
+}
+
+export { StoredPageVisit as default };

package/dist/const_matchers.js

@@ -0,0 +1,260 @@
+/* eslint-disable require-jsdoc */
+// This file is generated by wsmatchers.   Don't directly edit this file
+const addToCartTextRegexArray = [
+  '\\b(view|add|my)\\b.*\\b(cart|bag|basket|bucket|box)\\b',
+
+  '\\b(buy now)\\b',
+
+  '^backorder$',
+
+  '\\b(acquista ora)\\b',
+
+  '\\b(buy this)\\b',
+
+  '\\b(ajouter|mon)\\b.*\\b(panier)\\b',
+
+  '\\b(aggiungi)\\b.*\\b(cart|borsa|carrello)\\b',
+
+  '^ajouter à la shopping bag$',
+
+  '^aggiungi$',
+
+  '^aggiungi alla shopping bag$',
+
+  '\\b(warenkorb)\\b',
+
+  '(^kaufen$)',
+
+  '^купить$',
+
+  '\\b(agregar)\\b.*\\b(carrito)\\b',
+
+  '\\b(adicionar)\\b.*\\b(carrinho)\\b',
+
+  '^carrinho$',
+
+  '^añadir al carrito de compras$',
+
+  '(^añadir al carrito$)',
+
+  '(add another)',
+
+  '(in winkelmand)',
+
+  '(sepete ekle)',
+
+  '(Lagg I Varukorgen)',
+
+  '(ΠΡΟΣΘΗΚΗ ΣΤΟ ΚΑΛΑΘΙ)',
+
+  '(Lägg i varukorgen)',
+
+  '(Köp)',
+
+  '(カートに追加)',
+
+  '^添加至购物袋$',
+
+  '^购买$',
+
+  '^購入する$',
+
+  '(أضف الى السلة)',
+];
+
+const checkoutStartedTextRegexArray = [
+  '(paypal)',
+
+  '(checkout|payment|check out)',
+
+  '(l.?achat|règlement|paiement|la commande)',
+
+  '(passer).*(commande)',
+
+  'valider mon panier',
+
+  '(acheter maintenant)',
+
+  '^caisse$',
+
+  '(gå vidare till kassan)',
+
+  '(cassa|acquisto)',
+
+  '^vai alla cassa$',
+
+  '^procedi all.?acquisto$',
+
+  '^procedi al checkout$',
+
+  '^siguiente$',
+
+  '(kasse)',
+
+  '^zur kasse gehen$',
+
+  '^bezahlen$',
+
+  '^weiter zum checkout$',
+
+  '(comprar ahora)',
+
+  '^comprar$',
+
+  '(prosseguir com a compra)',
+
+  '^pasar por la caja$',
+
+  '^afrekenen$',
+
+  '^compre$',
+
+  '(continue to pay)',
+
+  '(naar de kassa)',
+
+  'Перейти к оформлению заказа',
+
+  '^купить сейчас$',
+
+  '^bestellen$',
+
+  '(Alışverişi Tamamla)',
+
+  '^Till kassan$',
+
+  '(チェックアウトに進む)',
+
+  '^去结算$',
+
+  '^付款。$',
+
+  '^お支払い$',
+
+  '(تاكيد الطلب)',
+];
+
+const checkoutPlaceOrderRegexArray = [
+  '(checkout|continue) (with paypal)',
+
+  '^continue to paypal$',
+
+  '^weiter zu paypal$',
+
+  '^continue to afterpay$',
+
+  '^braintree_paypal$',
+
+  '^pay and place order$',
+
+  '^mit paypal bezahlen$',
+
+  '^continue to payment securely$',
+
+  '(continua su paypal)',
+
+  '(apple pay|applepay)',
+
+  '(amazon pay|amazonpay|continue with amazon)',
+
+  '(sezzlepay)',
+
+  '(place order)',
+
+  '(place your order)',
+
+  '(order confirmation)',
+
+  '(complete purchase)',
+
+  'submit.*order',
+
+  '(pay now)',
+
+  '(^pay it now$)',
+
+  '(make payment)',
+
+  '(^make payment$)',
+
+  '(complete order)',
+
+  '^complete your order$',
+
+  '(fazer pedido)',
+
+  '^encomendar$',
+
+  '((realizar) (pedido|pago))',
+
+  '^finalizar compra$',
+
+  '^pagar$',
+
+  '^jetzt kaufen$',
+
+  '^bestellung aufgeben$',
+
+  '^bestellung prüfen$',
+
+  '^auftragsbestätigung$',
+
+  '^bestelling plaatsen$',
+
+  '^passer la commande$',
+
+  '(je confirme et je paye)',
+
+  '(accéder au paiement)',
+
+  '^passer au paiement$',
+
+  '(Valider et continuer)',
+
+  '^valider la commande$',
+
+  '(^passez la commande$)',
+
+  '^invia ordine$',
+
+  '(effettua ordine)',
+
+  '^effettua l.?ordine$',
+
+  '(conferma acquisto)',
+
+  '^conferma l.?acquisto$',
+
+  '^confirmation de commande$',
+
+  '^confirma l.?ordine$',
+
+  '^conferma l.?ordine$',
+
+  '^conferma ordine$',
+
+  '(SİPARİŞİ TAMAMLA)',
+
+  '^Разместить заказ$',
+
+  '(Slutför köp)',
+
+  '(注文する)',
+
+  '(إنشاء الطلب)',
+
+  '(注文を確定)',
+
+  '^お支払いへ進む$',
+
+  '^确认下单$',
+];
+
+function WHITELIST_TEXT_REGEX_STRING() {
+  return addToCartTextRegexArray
+    .concat(checkoutStartedTextRegexArray)
+    .concat(checkoutPlaceOrderRegexArray)
+    .join('|');
+}
+
+export { WHITELIST_TEXT_REGEX_STRING };