@newrelic/browser-agent 0.1.229 → 0.1.230

package/src/common/util/get-or-set.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var has = Object.prototype.hasOwnProperty
+
+// Always returns the current value of obj[prop], even if it has to set it first
+export function getOrSet (obj, prop, getVal) {
+  // If the value exists return it.
+  if (has.call(obj, prop)) return obj[prop]
+
+  var val = getVal()
+
+  // Attempt to set the property so it's not enumerable
+  if (Object.defineProperty && Object.keys) {
+    try {
+      Object.defineProperty(obj, prop, {
+        value: val, // old IE inherits non-write-ability
+        writable: true,
+        enumerable: false
+      })
+
+      return val
+    } catch (e) {
+      // Can't report internal errors,
+      // because GOS is a dependency of the reporting mechanisms
+    }
+  }
+
+  // fall back to setting normally
+  obj[prop] = val
+  return val
+}

package/src/common/util/global-scope.js

@@ -0,0 +1,48 @@
+/* global globalThis, WorkerGlobalScope, WorkerNavigator */
+
+export const isBrowserScope =
+  Boolean(typeof window !== 'undefined' && window.document)
+
+export const isWorkerScope =
+  Boolean(typeof WorkerGlobalScope !== 'undefined' && self.navigator instanceof WorkerNavigator)
+
+export let globalScope = (() => {
+  if (isBrowserScope) {
+    return window
+  } else if (isWorkerScope) {
+    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
+      return globalThis
+    } else if (self instanceof WorkerGlobalScope) {
+      return self
+    }
+  }
+
+  throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
+})()
+
+/**
+ * The below methods are only used for testing and should be removed once the
+ * reliant tests are moved to Jest.
+ * tests/browser/protocol.browser.js
+ * tests/browser/obfuscate.browser.js
+ */
+export function setScope (obj) {
+  globalScope = { ...obj }
+}
+export function resetScope () {
+  if (isBrowserScope) {
+    globalScope = window
+  } else if (isWorkerScope) {
+    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
+      globalScope = globalThis
+    } else if (self instanceof WorkerGlobalScope) {
+      globalScope = self
+    }
+  }
+  else {
+    throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
+  }
+}
+export function getGlobalScope () {
+  return globalScope
+}

package/src/common/util/map-own.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @typedef {function} MapOwnCallback
+ * @param {string} key Object key
+ * @param {any} value Object value
+ * @returns {any}
+ */
+
+/**
+ * Iterates the own enumerable properties of an object passing the key and value pair to a given
+ * callback function.
+ * @param {object} obj Input object to iterate over. If null or undefined, an empty array will be returned.
+ * @param {MapOwnCallback} fn A callback function called for each property. The callback should take the key
+ * and value from the object iteration and return some value.
+ * @returns {any[]} An array of values returned by the callback function.
+ */
+export const mapOwn = (obj, fn) => Object.entries(obj || {})
+  .map(([key, value]) => fn(key, value))

package/src/common/util/map-own.test.js

@@ -0,0 +1,52 @@
+import { mapOwn } from './map-own'
+
+test('enumerates the object properties', () => {
+  const callback = jest.fn()
+  const input = { foo: 'bar' }
+
+  mapOwn(input, callback)
+
+  expect(callback).toHaveBeenCalledWith('foo', 'bar')
+})
+
+test('return array of results from callback invocation', () => {
+  const callback = jest.fn((key, value) => `${key}:${value}`)
+  const input = { foo: 'bar', biz: 'baz' }
+
+  const result = mapOwn(input, callback)
+
+  expect(result.length).toEqual(2)
+  expect(result).toContain('foo:bar')
+  expect(result).toContain('biz:baz')
+})
+
+test('does not iterate symbol properties', () => {
+  const callback = jest.fn((key, value) => `${key}:${value}`)
+  const input = { foo: 'bar', [Symbol.for('biz')]: 'baz' }
+
+  const result = mapOwn(input, callback)
+
+  expect(result.length).toEqual(1)
+})
+
+test('does not iterate inherited properties', () => {
+  function F () {}
+  F.prototype = { biz: 'baz' }
+
+  const callback = jest.fn((key, value) => `${key}:${value}`)
+  const input = new F()
+  input.foo = 'bar'
+
+  const result = mapOwn(input, callback)
+
+  expect(result.length).toEqual(1)
+})
+
+test.each([null, undefined])('returns empty array when passed object is null or undefined', (input) => {
+  const callback = jest.fn()
+  const result = mapOwn(input, callback)
+
+  expect(Array.isArray(result)).toEqual(true)
+  expect(result.length).toEqual(0)
+  expect(callback).toHaveBeenCalledTimes(0)
+})

package/src/common/util/obfuscate.js

@@ -0,0 +1,73 @@
+import { getConfigurationValue } from '../config/config'
+import { SharedContext } from '../context/shared-context'
+import { protocol } from '../url/protocol'
+import { warn } from './console'
+
+var fileProtocolRule = {
+  regex: /^file:\/\/(.*)/,
+  replacement: 'file://OBFUSCATED'
+}
+export class Obfuscator extends SharedContext {
+  constructor (parent) {
+    super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
+  }
+
+  shouldObfuscate () {
+    return getRules(this.sharedContext.agentIdentifier).length > 0
+  }
+
+  // applies all regex obfuscation rules to provided URL string and returns the result
+  obfuscateString (string) {
+    // if string is empty string, null or not a string, return unmodified
+    if (!string || typeof string !== 'string') return string
+
+    var rules = getRules(this.sharedContext.agentIdentifier)
+    var obfuscated = string
+
+    // apply every rule to URL string
+    for (var i = 0; i < rules.length; i++) {
+      var regex = rules[i].regex
+      var replacement = rules[i].replacement || '*'
+      obfuscated = obfuscated.replace(regex, replacement)
+    }
+    return obfuscated
+  }
+}
+
+// TO DO: this function should be inside the Obfuscator class since its context relates to agentID
+export function getRules (agentIdentifier) {
+  var rules = []
+  var configRules = getConfigurationValue(agentIdentifier, 'obfuscate') || []
+
+  rules = rules.concat(configRules)
+
+  if (protocol.isFileProtocol()) rules.push(fileProtocolRule)
+  // could add additional runtime/environment-specific rules here
+
+  return rules
+}
+
+// takes array of rule objects, logs warning and returns false if any portion of rule is invalid
+export function validateRules (rules) {
+  var invalidReplacementDetected = false
+  var invalidRegexDetected = false
+  for (var i = 0; i < rules.length; i++) {
+    if (!('regex' in rules[i])) {
+      warn('An obfuscation replacement rule was detected missing a "regex" value.')
+      invalidRegexDetected = true
+    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex.constructor === RegExp)) {
+      warn('An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp)')
+      invalidRegexDetected = true
+    }
+
+    var replacement = rules[i].replacement
+    if (replacement) {
+      if (typeof replacement !== 'string') {
+        warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)')
+        invalidReplacementDetected = true
+      }
+    }
+  }
+
+  return !invalidReplacementDetected && !invalidRegexDetected
+}

package/src/common/util/s-hash.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function sHash (s) {
+  var i
+  var h = 0
+
+  for (i = 0; i < s.length; i++) {
+    h += ((i + 1) * s.charCodeAt(i))
+  }
+  return Math.abs(h)
+}

package/src/common/util/single.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import slice from 'lodash._slice'
+
+export function single (fn) {
+  var called = false
+  var res
+
+  return function () {
+    if (called) return res
+    called = true
+    res = fn.apply(this, slice(arguments))
+    return res
+  }
+}

package/src/common/util/stringify.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee } from '../event-emitter/contextual-ee'
+
+/**
+ * Returns a function for use as a replacer parameter in JSON.stringify() to handle circular references.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value MDN - Cyclical object value}
+ * @returns {Function} A function that filters out values it has seen before.
+ */
+const getCircularReplacer = () => {
+  const seen = new WeakSet()
+  return (key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return
+      }
+      seen.add(value)
+    }
+    return value
+  }
+}
+
+/**
+ * The native JSON.stringify method augmented with a replacer function to handle circular references.
+ * Circular references will be excluded from the JSON output rather than triggering errors.
+ * @param {*} val - A value to be converted to a JSON string.
+ * @returns {string} A JSON string representation of the value, with circular references handled.
+ */
+export function stringify (val) {
+  try {
+    return JSON.stringify(val, getCircularReplacer())
+  } catch (e) {
+    try {
+      ee.emit('internal-error', [e])
+    } catch (err) {
+      // do nothing
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isWorkerScope } from './global-scope'
+export const submitData = {}
+
+/**
+ * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @param {string} jsonp
+ * @returns {Element}
+ */
+submitData.jsonp = function jsonp (url, jsonp) {
+  try {
+    if (isWorkerScope) {
+      try {
+        return importScripts(url + '&jsonp=' + jsonp)
+      } catch (e) {
+        // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
+        // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
+        submitData.xhrGet(url + '&jsonp=' + jsonp)
+        return false
+      }
+    } else {
+      var element = document.createElement('script')
+      element.type = 'text/javascript'
+      element.src = url + '&jsonp=' + jsonp
+      var firstScript = document.getElementsByTagName('script')[0]
+      firstScript.parentNode.insertBefore(element, firstScript)
+      return element
+    }
+  } catch (err) {
+  // do nothing
+  }
+}
+
+submitData.xhrGet = function xhrGet (url) {
+  return submitData.xhr(url, undefined, false, 'GET')
+}
+
+/**
+ * Send via XHR
+ * @param {string} url
+ * @param {string} body
+ * @param {boolean} sync
+ * @returns {XMLHttpRequest}
+ */
+submitData.xhr = function xhr (url, body, sync, method = 'POST') {
+  var request = new XMLHttpRequest()
+
+  request.open(method, url, !sync)
+  try {
+    // Set cookie
+    if ('withCredentials' in request) request.withCredentials = true
+  } catch (e) {
+    // do nothing
+  }
+
+  request.setRequestHeader('content-type', 'text/plain')
+  request.send(body)
+  return request
+}
+
+/**
+ * Unused at the moment -- DEPRECATED
+ */
+// submitData.xhrSync = function xhrSync (url, body) {
+//   return submitData.xhr(url, body, true)
+// }
+
+/**
+ * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @returns {Element}
+ */
+submitData.img = function img (url) {
+  var element = new Image()
+  element.src = url
+  return element
+}
+
+/**
+ * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @param {string} body
+ * @returns {boolean}
+ */
+submitData.beacon = function (url, body) {
+  // Navigator has to be bound to ensure it does not error in some browsers
+  // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
+  const send = window.navigator.sendBeacon.bind(window.navigator)
+  try {
+    return send(url, body)
+  } catch (err) {
+    // if sendBeacon still trys to throw an illegal invocation error,
+    // we can catch here and return.  The harvest module will fallback to use
+    // .img to try to send
+    return false
+  }
+}

package/src/common/util/traverse.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// traverses an object and applies a fn to property values of a certain type
+export function applyFnToProps (obj, fn, type, ignoreKeys) {
+  if (!obj || typeof obj !== 'object') return obj
+  type = type || 'string'
+  ignoreKeys = ignoreKeys || []
+  return traverse(obj)
+  function traverse (obj) {
+    for (var property in obj) {
+      // eslint-disable-next-line
+      if (obj.hasOwnProperty(property)) {
+        if (typeof obj[property] === 'object') {
+          traverse(obj[property])
+        } else {
+          if (typeof obj[property] === type && !shouldIgnore(property)) obj[property] = fn(obj[property])
+        }
+      }
+    }
+    return obj
+  }
+
+  function shouldIgnore (key) {
+    var ignore = false
+    for (var i = 0; i < ignoreKeys.length; i++) {
+      if (ignoreKeys[i] === key) {
+        ignore = true
+        break
+      }
+    }
+    return ignore
+  }
+}

package/src/common/util/user-agent.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Feature-detection is much preferred over using User Agent to detect browser.
+// However, there are cases where feature detection is not possible, for example
+// when a specific version of a browser has a bug that requires a workaround in just
+// that version.
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Browser_Name
+var agentName = null
+var agentVersion = null
+const safari = /Version\/(\S+)\s+Safari/
+
+if (navigator.userAgent) {
+  var userAgent = navigator.userAgent
+  var parts = userAgent.match(safari)
+
+  if (parts && userAgent.indexOf('Chrome') === -1 &&
+      userAgent.indexOf('Chromium') === -1) {
+    agentName = 'Safari'
+    agentVersion = parts[1]
+  }
+}
+
+export { agentName as agent, agentVersion as version }
+
+export function match (name, version) {
+  if (!agentName) {
+    return false
+  }
+
+  if (name !== agentName) {
+    return false
+  }
+
+  // version not provided, only match by name
+  if (!version) {
+    return true
+  }
+
+  // version provided, but not detected - not reliable match
+  if (!agentVersion) {
+    return false
+  }
+
+  var detectedParts = agentVersion.split('.')
+  var requestedParts = version.split('.')
+  for (var i = 0; i < requestedParts.length; i++) {
+    if (requestedParts[i] !== detectedParts[i]) {
+      return false
+    }
+  }
+
+  return true
+}

package/src/common/window/load.js

@@ -0,0 +1,15 @@
+import { windowAddEventListener, documentAddEventListener } from '../event-listener/event-listener-opts'
+
+function checkState () {
+  return (typeof document === 'undefined' || document.readyState === 'complete')
+}
+
+export function onWindowLoad (cb, useCapture) {
+  if (checkState()) return cb()
+  windowAddEventListener('load', cb, useCapture)
+}
+
+export function onDOMContentLoaded (cb) {
+  if (checkState()) return cb()
+  documentAddEventListener('DOMContentLoaded', cb)
+}

package/src/common/window/nreum.js

@@ -0,0 +1,110 @@
+
+import { now } from '../timing/now'
+import { globalScope } from '../util/global-scope'
+
+export const defaults = {
+  beacon: 'bam.nr-data.net',
+  errorBeacon: 'bam.nr-data.net'
+}
+
+export function gosNREUM () {
+  if (!globalScope.NREUM) {
+    globalScope.NREUM = {}
+  }
+  if (typeof globalScope.newrelic === 'undefined') globalScope.newrelic = globalScope.NREUM
+  return globalScope.NREUM
+}
+
+export function gosNREUMInfo () {
+  let nr = gosNREUM()
+  const externallySupplied = nr.info || {}
+
+  nr.info = {
+    beacon: defaults.beacon,
+    errorBeacon: defaults.errorBeacon,
+    ...externallySupplied
+  }
+
+  return nr
+}
+
+export function gosNREUMLoaderConfig () {
+  let nr = gosNREUM()
+  const externallySupplied = nr.loader_config || {}
+
+  nr.loader_config = {
+    ...externallySupplied
+  }
+
+  return nr
+}
+
+export function gosNREUMInit () {
+  let nr = gosNREUM()
+  const externallySupplied = nr.init || {}
+
+  nr.init = {
+    ...externallySupplied
+  }
+
+  return nr
+}
+
+export function gosNREUMOriginals () {
+  let nr = gosNREUM()
+  if (!nr.o) {
+    nr.o = {
+      ST: globalScope.setTimeout,
+      SI: globalScope.setImmediate,
+      CT: globalScope.clearTimeout,
+      XHR: globalScope.XMLHttpRequest,
+      REQ: globalScope.Request,
+      EV: globalScope.Event,
+      PR: globalScope.Promise,
+      MO: globalScope.MutationObserver, // this'll be undefined if not in a web window
+      FETCH: globalScope.fetch
+    }
+  }
+  return nr
+}
+
+export function gosNREUMInitializedAgents (id, obj, target) {
+  let nr = gosNREUM()
+  const externallySupplied = nr.initializedAgents || {}
+  const curr = externallySupplied[id] || {}
+
+  if (!Object.keys(curr).length) {
+    curr.initializedAt = {
+      ms: now(),
+      date: new Date()
+    }
+  }
+
+  nr.initializedAgents = {
+    ...externallySupplied,
+    [id]: {
+      ...curr,
+      [target]: obj
+    }
+  }
+
+  return nr
+}
+
+export function addToNREUM (fnName, fn) {
+  let nr = gosNREUM()
+  nr[fnName] = fn
+}
+
+export function NREUMinitialized () {
+  const nr = gosNREUM()
+  nr.initialized = true
+}
+
+export function gosCDN () {
+  gosNREUMInfo()
+  gosNREUMInit()
+  gosNREUMOriginals()
+  gosNREUMLoaderConfig()
+  return gosNREUM()
+}

package/src/common/window/page-visibility.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { documentAddEventListener } from '../event-listener/event-listener-opts'
+
+/**
+ * @param {function} cb - called when a visibility change occurs with the vis state at that time
+ * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
+ * @returns void
+ */
+export function subscribeToVisibilityChange (cb, toHiddenOnly = false) {
+  documentAddEventListener('visibilitychange', handleVisibilityChange)
+  return
+
+  function handleVisibilityChange () {
+    if (toHiddenOnly) { // trigger cb on change to hidden state only
+      if (document.visibilityState == 'hidden') cb()
+      else return
+    }
+    cb(document.visibilityState)
+  }
+}