@newrelic/browser-agent 0.0.9 → 0.1.230

package/src/common/harvest/harvest.js

@@ -0,0 +1,248 @@
+/*
+ * 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)
+    }
+
+    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0
+
+    /* 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/src/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/src/common/ids/unique-id.js

@@ -0,0 +1,81 @@
+/*
+ * 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/src/common/metrics/framework-detection.js

@@ -0,0 +1,71 @@
+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/src/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/src/common/serialize/bel-serializer.js

@@ -0,0 +1,93 @@
+/*
+ * 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/src/common/timing/nav-timing.js

@@ -0,0 +1,70 @@
+/*
+ * 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/src/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/src/common/unload/eol.js

@@ -0,0 +1,63 @@
+/*
+ * 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/src/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')
+}