@newrelic/browser-agent 0.1.229 → 0.1.230

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')
+}

package/src/common/url/encode.js

@@ -0,0 +1,75 @@
+/*
+ * 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'
+
+// Characters that are safe in a qs, but get encoded.
+var charMap = {
+  '%2C': ',',
+  '%3A': ':',
+  '%2F': '/',
+  '%40': '@',
+  '%24': '$',
+  '%3B': ';'
+}
+
+var charList = mapOwn(charMap, function (k) { return k })
+var safeEncoded = new RegExp(charList.join('|'), 'g')
+
+function real (c) {
+  return charMap[c]
+}
+
+// Encode as URI Component, then unescape anything that is ok in the
+// query string position.
+export function qs (value) {
+  if (value === null || value === undefined) return 'null'
+  return encodeURIComponent(value).replace(safeEncoded, real)
+}
+
+export function fromArray (qs, maxBytes) {
+  var bytes = 0
+  for (var i = 0; i < qs.length; i++) {
+    bytes += qs[i].length
+    if (bytes > maxBytes) return qs.slice(0, i).join('')
+  }
+  return qs.join('')
+}
+
+export function obj (payload, maxBytes) {
+  var total = 0
+  var result = ''
+
+  mapOwn(payload, function (feature, dataArray) {
+    var intermediate = []
+    var next
+    var i
+
+    if (typeof dataArray === 'string') {
+      next = '&' + feature + '=' + qs(dataArray)
+      total += next.length
+      result += next
+    } else if (dataArray.length) {
+      total += 9
+      for (i = 0; i < dataArray.length; i++) {
+        next = qs(stringify(dataArray[i]))
+        total += next.length
+        if (typeof maxBytes !== 'undefined' && total >= maxBytes) break
+        intermediate.push(next)
+      }
+      result += '&' + feature + '=%5B' + intermediate.join(',') + '%5D'
+    }
+  })
+  return result
+}
+
+// Constructs an HTTP parameter to add to the BAM router URL
+export function param (name, value) {
+  if (value && typeof (value) === 'string') {
+    return '&' + name + '=' + qs(value)
+  }
+  return ''
+}

package/src/common/url/location.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function getLocation () {
+  return '' + location
+}

package/src/common/url/parse-url.js

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { globalScope, isBrowserScope } from '../util/global-scope'
+
+var stringsToParsedUrls = {}
+
+export function parseUrl (url) {
+  if (url in stringsToParsedUrls) {
+    return stringsToParsedUrls[url]
+  }
+
+  // Return if URL is a data URL, parseUrl assumes urls are http/https
+  if ((url || '').indexOf('data:') === 0) {
+    return {
+      protocol: 'data'
+    }
+  }
+
+  let urlEl
+  var location = globalScope?.location
+  var ret = {}
+
+  if (isBrowserScope) {
+    // Use an anchor dom element to resolve the url natively.
+    urlEl = document.createElement('a')
+    urlEl.href = url
+  }
+  else {
+    try {
+      urlEl = new URL(url, location.href)
+    } catch (err) {
+      return ret
+    }
+  }
+
+  ret.port = urlEl.port
+
+  var firstSplit = urlEl.href.split('://')
+
+  if (!ret.port && firstSplit[1]) {
+    ret.port = firstSplit[1].split('/')[0].split('@').pop().split(':')[1]
+  }
+  if (!ret.port || ret.port === '0') ret.port = (firstSplit[0] === 'https' ? '443' : '80')
+
+  // Host not provided in IE for relative urls
+  ret.hostname = (urlEl.hostname || location.hostname)
+
+  ret.pathname = urlEl.pathname
+
+  ret.protocol = firstSplit[0]
+
+  // Pathname sometimes doesn't have leading slash (IE 8 and 9)
+  if (ret.pathname.charAt(0) !== '/') ret.pathname = '/' + ret.pathname
+
+  // urlEl.protocol is ':' in old ie when protocol is not specified
+  var sameProtocol = !urlEl.protocol || urlEl.protocol === ':' || urlEl.protocol === location.protocol
+  var sameDomain = urlEl.hostname === location.hostname && urlEl.port === location.port
+
+  // urlEl.hostname is not provided by IE for relative urls, but relative urls are also same-origin
+  ret.sameOrigin = sameProtocol && (!urlEl.hostname || sameDomain)
+
+  // Only cache if url doesn't have a path
+  if (ret.pathname === '/') {
+    stringsToParsedUrls[url] = ret
+  }
+
+  return ret
+}

package/src/common/url/protocol.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getGlobalScope } from '../util/global-scope'
+
+export const protocol = {
+  isFileProtocol: isFileProtocol,
+  supportabilityMetricSent: false
+}
+
+function isFileProtocol () {
+  let isFile = Boolean(getGlobalScope()?.location?.protocol === 'file:')
+  if (isFile) {
+    //metrics.recordSupportability('Generic/FileProtocol/Detected') -- may be implemented later? Probably make sure it's once per window
+    protocol.supportabilityMetricSent = true
+  }
+  return isFile
+}

package/src/common/util/console.js

@@ -0,0 +1,11 @@
+/**
+ * A helper method to warn to the console with New Relic: decoration
+ * @param {string} message - The primary message to warn
+ * @param {*} secondary - Secondary data to include, usually an error or object
+ * @returns
+ */
+export function warn (message, secondary) {
+  if (typeof console.warn !== 'function') return
+  console.warn(`New Relic: ${message}`)
+  if (secondary) console.warn(secondary)
+}

package/src/common/util/data-size.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { stringify } from './stringify'
+
+export function dataSize (data) {
+  if (typeof data === 'string' && data.length) return data.length
+  if (typeof data !== 'object') return undefined
+  // eslint-disable-next-line
+  if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer && data.byteLength) return data.byteLength
+  if (typeof Blob !== 'undefined' && data instanceof Blob && data.size) return data.size
+  if (typeof FormData !== 'undefined' && data instanceof FormData) return undefined
+
+  try {
+    return stringify(data).length
+  } catch (e) {
+    return undefined
+  }
+}

package/src/common/util/feature-flags.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mapOwn } from './map-own'
+import { ee } from '../event-emitter/contextual-ee'
+import { handle } from '../event-emitter/handle'
+import { drain } from '../drain/drain'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+const bucketMap = {
+  stn: [FEATURE_NAMES.sessionTrace],
+  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
+  ins: [FEATURE_NAMES.pageAction],
+  spa: [FEATURE_NAMES.spa]
+}
+
+export function activateFeatures (flags, agentIdentifier) {
+  var sharedEE = ee.get(agentIdentifier)
+  if (!(flags && typeof flags === 'object')) return
+  mapOwn(flags, function (flag, val) {
+    if (!val) {
+      return (bucketMap[flag] || []).forEach(feat => {
+        handle('block-' + flag, [], undefined, feat, sharedEE)
+      })
+    }
+
+    if (activatedFeatures[flag]) {
+      return
+    }
+
+    handle('feat-' + flag, [], undefined, bucketMap[flag], sharedEE)
+    activatedFeatures[flag] = true
+  })
+  drain(agentIdentifier, FEATURE_NAMES.pageViewEvent)
+}
+
+export const activatedFeatures = {}