@newrelic/browser-agent 0.0.9 → 0.1.229

package/dist/esm/common/harvest/harvest.js

@@ -0,0 +1,228 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { mapOwn } from '../util/map-own';
+import { obj as encodeObj, param as encodeParam } from '../url/encode';
+import { stringify } from '../util/stringify';
+import { submitData } from '../util/submit-data';
+import { getLocation } from '../url/location';
+import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config';
+import { cleanURL } from '../url/clean-url';
+import { now } from '../timing/now';
+import { eventListenerOpts } from '../event-listener/event-listener-opts';
+import { Obfuscator } from '../util/obfuscate';
+import { applyFnToProps } from '../util/traverse';
+import { SharedContext } from '../context/shared-context';
+import { VERSION } from '../constants/environment-variables';
+import { isBrowserScope, isWorkerScope } from '../util/global-scope';
+const haveSendBeacon = !!navigator.sendBeacon; // only the web window obj has sendBeacon at this time, so 'false' for other envs
+
+export class Harvest extends SharedContext {
+  constructor(parent) {
+    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
+
+    this.tooManyRequestsDelay = getConfigurationValue(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60;
+    this.obfuscator = new Obfuscator(this.sharedContext);
+    this.getScheme = () => getConfigurationValue(this.sharedContext.agentIdentifier, 'ssl') === false ? 'http' : 'https';
+    this._events = {};
+  }
+
+  /**
+   * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
+   * name is emitted, which gives any listeners the opportunity to provide payload data.
+   *
+   * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+   *
+   * @param {object} opts
+   * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+   */
+  sendX(endpoint, opts, cbFinished) {
+    var submitMethod = getSubmitMethod(endpoint, opts);
+    if (!submitMethod) return false;
+    var options = {
+      retry: submitMethod.method === submitData.xhr
+    };
+    return this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished) : this._send(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished);
+  }
+
+  /**
+  * Initiate a harvest call.
+  *
+  * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+  * @param {object} nr - The loader singleton.
+  *
+  * @param {object} singlePayload - Object representing payload.
+  * @param {object} singlePayload.qs - Map of values that should be sent as part of the request query string.
+  * @param {string} singlePayload.body - String that should be sent as the body of the request.
+  * @param {string} singlePayload.body.e - Special case of body used for browser interactions.
+  *
+  * @param {object} opts
+  * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+  * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+  */
+  send(endpoint, singlePayload, opts, submitMethod, cbFinished) {
+    var makeBody = createAccumulator();
+    var makeQueryString = createAccumulator();
+    if (singlePayload.body) mapOwn(singlePayload.body, makeBody);
+    if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString);
+    var payload = {
+      body: makeBody(),
+      qs: makeQueryString()
+    };
+    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args);
+    return caller(endpoint, payload, opts, submitMethod, cbFinished);
+  }
+  obfuscateAndSend(endpoint, payload, opts, submitMethod, cbFinished) {
+    applyFnToProps(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e']);
+    return this._send(endpoint, payload, opts, submitMethod, cbFinished);
+  }
+  _send(endpoint, payload, opts, submitMethod, cbFinished) {
+    var info = getInfo(this.sharedContext.agentIdentifier);
+    if (!info.errorBeacon) return false;
+    var agentRuntime = getRuntime(this.sharedContext.agentIdentifier);
+    if (!payload.body) {
+      // no payload body? nothing to send, just run onfinish stuff and return
+      if (cbFinished) {
+        cbFinished({
+          sent: false
+        });
+      }
+      return false;
+    }
+    if (!opts) opts = {};
+    var url = this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + this.baseQueryString();
+    if (payload.qs) url += encodeObj(payload.qs, agentRuntime.maxBytes);
+    if (!submitMethod) {
+      submitMethod = getSubmitMethod(endpoint, opts);
+    }
+    var method = submitMethod.method;
+    var useBody = submitMethod.useBody;
+    var body;
+    var fullUrl = url;
+    if (useBody && endpoint === 'events') {
+      body = payload.body.e;
+    } else if (useBody) {
+      body = stringify(payload.body);
+    } else {
+      fullUrl = url + encodeObj(payload.body, agentRuntime.maxBytes);
+    }
+
+    /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
+        Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
+        we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */
+    var result = method(fullUrl, body, opts.unload && isWorkerScope);
+    if (cbFinished && method === submitData.xhr) {
+      var xhr = result;
+      xhr.addEventListener('load', function () {
+        var result = {
+          sent: true
+        };
+        if (this.status === 429) {
+          result.retry = true;
+          result.delay = this.tooManyRequestsDelay;
+        } else if (this.status === 408 || this.status === 500 || this.status === 503) {
+          result.retry = true;
+        }
+        if (opts.needResponse) {
+          result.responseText = this.responseText;
+        }
+        cbFinished(result);
+      }, eventListenerOpts(false));
+    }
+
+    // if beacon request failed, retry with an alternative method -- will not happen for workers
+    if (!result && method === submitData.beacon) {
+      method = submitData.img;
+      result = method(url + encodeObj(payload.body, agentRuntime.maxBytes));
+    }
+    return result;
+  }
+
+  // The stuff that gets sent every time.
+  baseQueryString() {
+    var runtime = getRuntime(this.sharedContext.agentIdentifier);
+    var info = getInfo(this.sharedContext.agentIdentifier);
+    var location = cleanURL(getLocation());
+    var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
+    return ['?a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
+    // ck param DEPRECATED - still expected by backend
+    '&s=' + (runtime.sessionId || '0'),
+    // the 0 id encaps all untrackable and default traffic
+    encodeParam('ref', ref), encodeParam('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
+  }
+  createPayload(type, options) {
+    var makeBody = createAccumulator();
+    var makeQueryString = createAccumulator();
+    var listeners = this._events[type] && this._events[type] || [];
+    for (var i = 0; i < listeners.length; i++) {
+      var singlePayload = listeners[i](options);
+      if (!singlePayload) continue;
+      if (singlePayload.body) mapOwn(singlePayload.body, makeBody);
+      if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString);
+    }
+    return {
+      body: makeBody(),
+      qs: makeQueryString()
+    };
+  }
+  on(type, listener) {
+    var listeners = this._events[type] || (this._events[type] = []);
+    listeners.push(listener);
+  }
+  resetListeners() {
+    mapOwn(this._events, key => {
+      this._events[key] = [];
+    });
+  }
+}
+function or(a, b) {
+  return a || b;
+}
+export function getSubmitMethod(endpoint, opts) {
+  opts = opts || {};
+  var method;
+  var useBody;
+  if (opts.needResponse) {
+    // currently: only STN needs a response
+    useBody = true;
+    method = submitData.xhr;
+  } else if (opts.unload && isBrowserScope) {
+    // all the features' final harvest; neither methods work outside window context
+    useBody = haveSendBeacon;
+    method = haveSendBeacon ? submitData.beacon : submitData.img; // really only IE doesn't have Beacon API for web browsers
+  } else {
+    // `submitData.beacon` was removed, there is an upper limit to the
+    // number of data allowed before it starts failing, so we save it only for page unloading
+    useBody = true;
+    method = submitData.xhr;
+  }
+  return {
+    method: method,
+    useBody: useBody
+  };
+}
+
+// Constructs the transaction name param for the beacon URL.
+// Prefers the obfuscated transaction name over the plain text.
+// Falls back to making up a name.
+function transactionNameParam(info) {
+  if (info.transactionName) return encodeParam('to', info.transactionName);
+  return encodeParam('t', info.tNamePlain || 'Unnamed Transaction');
+}
+
+// returns a function that can be called to accumulate values to a single object
+// when the function is called without parameters, then the accumulator is returned
+function createAccumulator() {
+  var accumulator = {};
+  var hasData = false;
+  return function (key, val) {
+    if (val && val.length) {
+      accumulator[key] = val;
+      hasData = true;
+    }
+    if (hasData) return accumulator;
+  };
+}

package/dist/esm/common/ids/id.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+import { getOrSet } from '../util/get-or-set';
+import { globalScope } from '../util/global-scope';
+var index = 1;
+var prop = 'nr@id';
+
+// Always returns id of obj, may tag obj with an id in the process.
+export function id(obj) {
+  var type = typeof obj;
+  // We can only tag objects, functions, and arrays with ids.
+  // For all primitive values we instead return -1.
+  if (!obj || !(type === 'object' || type === 'function')) return -1;
+  if (obj === globalScope) return 0;
+  return getOrSet(obj, prop, function () {
+    return index++;
+  });
+}

package/dist/esm/common/ids/unique-id.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { globalScope } from '../util/global-scope';
+export function generateUuid() {
+  var randomVals = null;
+  var rvIndex = 0;
+  var crypto = globalScope?.crypto || globalScope?.msCrypto;
+  if (crypto && crypto.getRandomValues) {
+    // eslint-disable-next-line
+    randomVals = crypto.getRandomValues(new Uint8Array(31));
+  }
+  function getRandomValue() {
+    if (randomVals) {
+      // same as % 16
+      return randomVals[rvIndex++] & 15;
+    } else {
+      return Math.random() * 16 | 0;
+    }
+  }
+
+  // v4 UUID
+  var template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  var id = '';
+  var c;
+  for (var i = 0; i < template.length; i++) {
+    c = template[i];
+    if (c === 'x') {
+      id += getRandomValue().toString(16);
+    } else if (c === 'y') {
+      // this is the uuid variant per spec (8, 9, a, b)
+      // % 4, then shift to get values 8-11
+      c = getRandomValue() & 0x3 | 0x8;
+      id += c.toString(16);
+    } else {
+      id += c;
+    }
+  }
+  return id;
+}
+
+// 16-character hex string (per DT spec)
+export function generateSpanId() {
+  return generateRandomHexString(16);
+}
+
+// 32-character hex string (per DT spec)
+export function generateTraceId() {
+  return generateRandomHexString(32);
+}
+export function generateRandomHexString(length) {
+  var randomVals = null;
+  var rvIndex = 0;
+  var crypto = self.crypto || self.msCrypto;
+  // eslint-disable-next-line
+  if (crypto && crypto.getRandomValues && Uint8Array) {
+    // eslint-disable-next-line
+    randomVals = crypto.getRandomValues(new Uint8Array(31));
+  }
+  var chars = [];
+  for (var i = 0; i < length; i++) {
+    chars.push(getRandomValue().toString(16));
+  }
+  return chars.join('');
+  function getRandomValue() {
+    if (randomVals) {
+      // same as % 16
+      return randomVals[rvIndex++] & 15;
+    } else {
+      return Math.random() * 16 | 0;
+    }
+  }
+}

package/dist/esm/common/metrics/framework-detection.js

@@ -0,0 +1,66 @@
+import { isBrowserScope } from '../util/global-scope';
+var FRAMEWORKS = {
+  REACT: 'React',
+  ANGULAR: 'Angular',
+  ANGULARJS: 'AngularJS',
+  BACKBONE: 'Backbone',
+  EMBER: 'Ember',
+  VUE: 'Vue',
+  METEOR: 'Meteor',
+  ZEPTO: 'Zepto',
+  JQUERY: 'Jquery'
+};
+export function getFrameworks() {
+  if (!isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
+
+  var frameworks = [];
+  try {
+    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
+    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
+    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
+    if (window.Backbone) frameworks.push(FRAMEWORKS.BACKBONE);
+    if (window.Ember) frameworks.push(FRAMEWORKS.EMBER);
+    if (window.Vue) frameworks.push(FRAMEWORKS.VUE);
+    if (window.Meteor) frameworks.push(FRAMEWORKS.METEOR);
+    if (window.Zepto) frameworks.push(FRAMEWORKS.ZEPTO);
+    if (window.jQuery) frameworks.push(FRAMEWORKS.JQUERY);
+  } catch (err) {
+    // not supported?
+  }
+  return frameworks;
+}
+function detectReact() {
+  try {
+    if (!!window.React || !!window.ReactDOM || !!window.ReactRedux) return true;
+    if (document.querySelector('[data-reactroot], [data-reactid]')) return true;
+    var divs = document.querySelectorAll('body > div');
+    for (var i = 0; i < divs.length; i++) {
+      if (Object.keys(divs[i]).indexOf('_reactRootContainer') >= 0) return true;
+    }
+    return false;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}
+function detectAngularJs() {
+  try {
+    if (window.angular) return true;
+    if (document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]')) return true;
+    if (document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]')) return true;
+    return false;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}
+function detectAngular() {
+  try {
+    // eslint-disable-next-line
+    if (window.hasOwnProperty('ng') && window.ng.hasOwnProperty('coreTokens') && window.ng.coreTokens.hasOwnProperty('NgZone')) return true;
+    return !!document.querySelectorAll('[ng-version]').length;
+  } catch (err) {
+    // not supported?
+    return false;
+  }
+}

package/dist/esm/common/metrics/paint-metrics.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const paintMetrics = {};

package/dist/esm/common/serialize/bel-serializer.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { mapOwn } from '../util/map-own';
+import { stringify } from '../util/stringify';
+import { Obfuscator } from '../util/obfuscate';
+var hasOwnProp = Object.prototype.hasOwnProperty;
+var MAX_ATTRIBUTES = 64;
+export function nullable(val, fn, comma) {
+  return val || val === 0 || val === '' ? fn(val) + (comma ? ',' : '') : '!';
+}
+export function numeric(n, noDefault) {
+  if (noDefault) {
+    return Math.floor(n).toString(36);
+  }
+  return n === undefined || n === 0 ? '' : Math.floor(n).toString(36);
+}
+export function getAddStringContext(agentIdentifier) {
+  // eslint-disable-next-line
+  var stringTable = Object.hasOwnProperty('create') ? Object.create(null) : {};
+  var stringTableIdx = 0;
+  return addString;
+  function addString(str) {
+    if (typeof str === 'undefined' || str === '') return '';
+    var obfuscator = new Obfuscator({
+      agentIdentifier: agentIdentifier
+    });
+    str = String(str);
+    if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str);
+    if (hasOwnProp.call(stringTable, str)) {
+      return numeric(stringTable[str], true);
+    } else {
+      stringTable[str] = stringTableIdx++;
+      return quoteString(str);
+    }
+  }
+}
+export function addCustomAttributes(attrs, addString) {
+  var attrParts = [];
+  mapOwn(attrs, function (key, val) {
+    if (attrParts.length >= MAX_ATTRIBUTES) return;
+    var type = 5;
+    var serializedValue;
+    // add key to string table first
+    key = addString(key);
+    switch (typeof val) {
+      case 'object':
+        if (val) {
+          // serialize objects to strings
+          serializedValue = addString(stringify(val));
+        } else {
+          // null attribute type
+          type = 9;
+        }
+        break;
+      case 'number':
+        type = 6;
+        // make sure numbers contain a `.` so they are parsed as doubles
+        serializedValue = val % 1 ? val : val + '.';
+        break;
+      case 'boolean':
+        type = val ? 7 : 8;
+        break;
+      case 'undefined':
+        // we treat undefined as a null attribute (since dirac does not have a concept of undefined)
+        type = 9;
+        break;
+      default:
+        serializedValue = addString(val);
+    }
+    attrParts.push([type, key + (serializedValue ? ',' + serializedValue : '')]);
+  });
+  return attrParts;
+}
+var escapable = /([,\\;])/g;
+function quoteString(str) {
+  return "'" + str.replace(escapable, '\\$1');
+}

package/dist/esm/common/timing/nav-timing.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// We don't use JSON.stringify directly on the performance timing data for these reasons:
+// * Chrome has extra data in the performance object that we don't want to send all the time (wasteful)
+// * Firefox fails to stringify the native object due to - http://code.google.com/p/v8/issues/detail?id=1223
+// * The variable names are long and wasteful to transmit
+
+// Add Performance Timing values to the given object.
+// * Values are written relative to an offset to reduce their length (i.e. number of characters).
+// * The offset is sent with the data
+// * 0's are not included unless the value is a 'relative zero'
+//
+
+var START = 'Start';
+var END = 'End';
+var UNLOAD_EVENT = 'unloadEvent';
+var REDIRECT = 'redirect';
+var DOMAIN_LOOKUP = 'domainLookup';
+var ONNECT = 'onnect';
+var REQUEST = 'request';
+var RESPONSE = 'response';
+var LOAD_EVENT = 'loadEvent';
+var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
+export var navTimingValues = [];
+export function addPT(offset, pt, v) {
+  v.of = offset;
+  addRel(offset, offset, v, 'n');
+  addRel(pt[UNLOAD_EVENT + START], offset, v, 'u');
+  addRel(pt[REDIRECT + START], offset, v, 'r');
+  addRel(pt[UNLOAD_EVENT + END], offset, v, 'ue');
+  addRel(pt[REDIRECT + END], offset, v, 're');
+  addRel(pt['fetch' + START], offset, v, 'f');
+  addRel(pt[DOMAIN_LOOKUP + START], offset, v, 'dn');
+  addRel(pt[DOMAIN_LOOKUP + END], offset, v, 'dne');
+  addRel(pt['c' + ONNECT + START], offset, v, 'c');
+  addRel(pt['secureC' + ONNECT + 'ion' + START], offset, v, 's');
+  addRel(pt['c' + ONNECT + END], offset, v, 'ce');
+  addRel(pt[REQUEST + START], offset, v, 'rq');
+  addRel(pt[RESPONSE + START], offset, v, 'rp');
+  addRel(pt[RESPONSE + END], offset, v, 'rpe');
+  addRel(pt.domLoading, offset, v, 'dl');
+  addRel(pt.domInteractive, offset, v, 'di');
+  addRel(pt[DOM_CONTENT_LOAD_EVENT + START], offset, v, 'ds');
+  addRel(pt[DOM_CONTENT_LOAD_EVENT + END], offset, v, 'de');
+  addRel(pt.domComplete, offset, v, 'dc');
+  addRel(pt[LOAD_EVENT + START], offset, v, 'l');
+  addRel(pt[LOAD_EVENT + END], offset, v, 'le');
+  return v;
+}
+
+// Add Performance Navigation values to the given object
+export function addPN(pn, v) {
+  addRel(pn.type, 0, v, 'ty');
+  addRel(pn.redirectCount, 0, v, 'rc');
+  return v;
+}
+export function addRel(value, offset, obj, prop) {
+  var relativeValue;
+  if (typeof value === 'number' && value > 0) {
+    relativeValue = Math.max(Math.round(value - offset), 0);
+    obj[prop] = relativeValue;
+  }
+  navTimingValues.push(relativeValue);
+}

package/dist/esm/common/timing/now.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// This is our own layer around performance.now. It's not strictly necessary, but we keep it in case of future mod-ing of the value for refactor purpose.
+export function now() {
+  return Math.round(performance.now());
+}

package/dist/esm/common/unload/eol.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ffVersion } from '../browser-version/firefox-version';
+import { windowAddEventListener } from '../event-listener/event-listener-opts';
+import { single } from '../util/single';
+import { globalScope, isWorkerScope, isBrowserScope } from '../util/global-scope';
+import { subscribeToVisibilityChange } from '../window/page-visibility';
+if (isWorkerScope) {
+  globalScope.cleanupTasks = []; // create new list on WorkerGlobalScope to track funcs to run before exiting thread
+
+  const origClose = globalScope.close;
+  globalScope.close = () => {
+    // on worker's EoL signal, execute all "listeners", e.g. final harvests
+    for (let task of globalScope.cleanupTasks) {
+      task();
+    }
+    origClose();
+  };
+}
+
+/**
+ * Subscribes a provided callback to the time/event when the agent should treat it as end-of-life.
+ * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
+ * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
+ * @param {boolean} allowBFCache - (temp) feature flag to gate new v1222 BFC support
+ */
+export function subscribeToEOL(cb, allowBFCache) {
+  if (isBrowserScope) {
+    if (allowBFCache) {
+      subscribeToVisibilityChange(cb, true); // when user switches tab or hides window, esp. mobile scenario
+      windowAddEventListener('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
+      // --this ought to be removed once support for version below 14.5 phases out
+    } else {
+      var oneCall = single(cb);
+
+      // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
+      // or 'unload' event will delay the 'load' event firing on the next page load.
+      // In Firefox versions that support sendBeacon, this doesn't matter, because
+      // we'll use it instead of an image load for our final harvest.
+      //
+      // Some Safari versions never fire the 'unload' event for pages that are being
+      // put into the WebKit page cache, so we *need* to use the pagehide event for
+      // the final submission from Safari.
+      //
+      // Generally speaking, we will try to submit our final harvest from either
+      // pagehide or unload, whichever comes first, but in Firefox, we need to avoid
+      // attempting to submit from pagehide to ensure that we don't slow down loading
+      // of the next page.
+      if (!ffVersion || navigator.sendBeacon) {
+        windowAddEventListener('pagehide', oneCall);
+      } else {
+        windowAddEventListener('beforeunload', oneCall);
+      }
+      windowAddEventListener('unload', oneCall);
+    }
+  } else if (isWorkerScope) {
+    globalScope.cleanupTasks.push(cb); // close() should run these tasks before quitting thread
+  }
+  // By default (for other env), this fn has no effect.
+}

package/dist/esm/common/url/clean-url.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/;
+var withoutHash = /([^?#]*)().*/;
+export function cleanURL(url, keepHash) {
+  return url.replace(keepHash ? withHash : withoutHash, '$1$2');
+}