@newrelic/browser-agent 1.258.0 → 1.258.1

package/src/features/ajax/instrument/index.js

@@ -17,6 +17,7 @@ import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC } from '../../metrics/constants'
 import { now } from '../../../common/timing/now'
+import { hasUndefinedHostname } from '../../../common/deny-list/deny-list'
 
 var handlers = ['load', 'error', 'abort', 'timeout']
 var handlersLen = handlers.length
@@ -338,18 +339,18 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
   // eslint-disable-next-line handle-callback-err
   function onFetchDone (_, res) {
     this.endTime = now()
-    if (!this.params) {
-      this.params = {}
-    }
+    if (!this.params) this.params = {}
+    if (hasUndefinedHostname(this.params)) return // don't bother with fetch to url with no hostname
+
     this.params.status = res ? res.status : 0
 
     // convert rxSize to a number
-    var responseSize
+    let responseSize
     if (typeof this.rxSize === 'string' && this.rxSize.length > 0) {
       responseSize = +this.rxSize
     }
 
-    var metrics = {
+    const metrics = {
       txSize: this.txSize,
       rxSize: responseSize,
       duration: now() - this.startTime
@@ -360,17 +361,18 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
 
   // Create report for XHR request that has finished
   function end (xhr) {
-    var params = this.params
-    var metrics = this.metrics
-
+    const params = this.params
+    const metrics = this.metrics
     if (this.ended) return
     this.ended = true
 
-    for (var i = 0; i < handlersLen; i++) {
+    for (let i = 0; i < handlersLen; i++) {
       xhr.removeEventListener(handlers[i], this.listener, false)
     }
 
     if (params.aborted) return
+    if (hasUndefinedHostname(params)) return // don't bother with XHR of url with no hostname
+
     metrics.duration = now() - this.startTime
     if (!this.loadCaptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr)

package/src/features/jserrors/aggregate/index.js

@@ -202,15 +202,20 @@ export class Aggregate extends AggregateBase {
 
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
-    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 
+    if (err.__newrelic?.[this.agentIdentifier]) {
+      params._interactionId = err.__newrelic[this.agentIdentifier].interactionId
+      params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId
+    }
+
     const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav])
     // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
     // They each will also tack on their respective properties to the params object as part of the decision flow.
     if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee)
-    else handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee)
+    else handle('spa-jserror', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee)
 
     if (params.browserInteractionId && !params._softNavFinished) { // hold onto the error until the in-progress interaction is done, eithered saved or discarded
       this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= []

package/src/features/jserrors/instrument/index.js

@@ -9,15 +9,13 @@ import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { globalScope } from '../../../common/constants/runtime'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
-import { stringify } from '../../../common/util/stringify'
-import { UncaughtError } from './uncaught-error'
 import { now } from '../../../common/timing/now'
 import { SR_EVENT_EMITTER_TYPES } from '../../session_replay/constants'
+import { castError, castErrorEvent, castPromiseRejectionEvent } from '../shared/cast-error'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
 
-  #seenErrors = new Set()
   #replayRunning = false
 
   constructor (agentIdentifier, aggregator, auto = true) {
@@ -28,17 +26,9 @@ export class Instrument extends InstrumentBase {
       this.removeOnAbort = new AbortController()
     } catch (e) {}
 
-    // Capture function errors early in case the spa feature is loaded
-    this.ee.on('fn-err', (args, obj, error) => {
-      if (!this.abortHandler || this.#seenErrors.has(error)) return
-      this.#seenErrors.add(error)
-
-      handle('err', [this.#castError(error), now()], undefined, FEATURE_NAMES.jserrors, this.ee)
-    })
-
     this.ee.on('internal-error', (error) => {
       if (!this.abortHandler) return
-      handle('ierr', [this.#castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     })
 
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
@@ -47,22 +37,12 @@ export class Instrument extends InstrumentBase {
 
     globalScope.addEventListener('unhandledrejection', (promiseRejectionEvent) => {
       if (!this.abortHandler) return
-      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     globalScope.addEventListener('error', (errorEvent) => {
       if (!this.abortHandler) return
-
-      /**
-       * If the spa feature is loaded, errors may already have been captured in the `fn-err` listener above.
-       * This ensures those errors are not captured twice.
-       */
-      if (this.#seenErrors.has(errorEvent.error)) {
-        this.#seenErrors.delete(errorEvent.error)
-        return
-      }
-
-      handle('err', [this.#castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     this.abortHandler = this.#abort // we also use this as a flag to denote that the feature is active or on and handling errors
@@ -72,81 +52,6 @@ export class Instrument extends InstrumentBase {
   /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
   #abort () {
     this.removeOnAbort?.abort()
-    this.#seenErrors.clear()
     this.abortHandler = undefined // weakly allow this abort op to run only once
   }
-
-  /**
-   * Any value can be used with the `throw` keyword. This function ensures that the value is
-   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
-   * @param {any} error The value thrown
-   * @returns {Error|UncaughtError} The converted error instance
-   */
-  #castError (error) {
-    if (error instanceof Error) {
-      return error
-    }
-
-    /**
-     * The thrown value may contain a message property. If it does, try to treat the thrown
-     * value as an Error-like object.
-     */
-    if (typeof error?.message !== 'undefined') {
-      return new UncaughtError(
-        error.message,
-        error.filename || error.sourceURL,
-        error.lineno || error.line,
-        error.colno || error.col
-      )
-    }
-
-    return new UncaughtError(typeof error === 'string' ? error : stringify(error))
-  }
-
-  /**
-   * Attempts to convert a PromiseRejectionEvent object to an Error object
-   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
-   * @returns {Error} An Error object with the message as the casted reason
-   */
-  #castPromiseRejectionEvent (promiseRejectionEvent) {
-    let prefix = 'Unhandled Promise Rejection: '
-
-    if (promiseRejectionEvent?.reason instanceof Error) {
-      try {
-        promiseRejectionEvent.reason.message = prefix + promiseRejectionEvent.reason.message
-        return promiseRejectionEvent.reason
-      } catch (e) {
-        return promiseRejectionEvent.reason
-      }
-    }
-
-    if (typeof promiseRejectionEvent.reason === 'undefined') return new UncaughtError(prefix)
-
-    const error = this.#castError(promiseRejectionEvent.reason)
-    error.message = prefix + error.message
-    return error
-  }
-
-  /**
-   * Attempts to convert an ErrorEvent object to an Error object
-   * @param {ErrorEvent} errorEvent The error event
-   * @returns {Error|UncaughtError} The error event converted to an Error object
-   */
-  #castErrorEvent (errorEvent) {
-    if (errorEvent.error instanceof SyntaxError && !/:\d+$/.test(errorEvent.error.stack?.trim())) {
-      const error = new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno)
-      error.name = SyntaxError.name
-      return error
-    }
-
-    if (errorEvent.error instanceof Error) {
-      return errorEvent.error
-    }
-
-    /**
-     * Older browsers do not contain the `error` property on the ErrorEvent instance.
-     * https://caniuse.com/mdn-api_errorevent_error
-     */
-    return new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno)
-  }
 }

package/src/features/jserrors/shared/cast-error.js

@@ -0,0 +1,69 @@
+import { UncaughtError } from './uncaught-error'
+
+/**
+   * Any value can be used with the `throw` keyword. This function ensures that the value is
+   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
+   * @param {any} error The value thrown
+   * @returns {Error|UncaughtError} The converted error instance
+   */
+export function castError (error) {
+  /** Sometimes a browser can emit an error object with no stack */
+  if (canTrustError(error)) {
+    return error
+  }
+
+  /**
+     * The thrown value may contain a message property. If it does, try to treat the thrown
+     * value as an Error-like object.
+     */
+  return new UncaughtError(
+    error?.message !== undefined ? error.message : error,
+    error?.filename || error?.sourceURL,
+    error?.lineno || error?.line,
+    error?.colno || error?.col,
+    error?.__newrelic
+  )
+}
+
+/**
+   * Attempts to convert a PromiseRejectionEvent object to an Error object
+   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
+   * @returns {Error} An Error object with the message as the casted reason
+   */
+export function castPromiseRejectionEvent (promiseRejectionEvent) {
+  let prefix = 'Unhandled Promise Rejection'
+
+  if (canTrustError(promiseRejectionEvent?.reason)) {
+    try {
+      promiseRejectionEvent.reason.message = prefix + ': ' + promiseRejectionEvent.reason.message
+      return castError(promiseRejectionEvent.reason)
+    } catch (e) {
+      return castError(promiseRejectionEvent.reason)
+    }
+  }
+
+  if (typeof promiseRejectionEvent.reason === 'undefined') return castError(prefix)
+
+  const error = castError(promiseRejectionEvent.reason)
+  error.message = prefix + ': ' + error?.message
+  return error
+}
+
+/**
+   * Attempts to convert an ErrorEvent object to an Error object
+   * @param {ErrorEvent} errorEvent The error event
+   * @returns {Error|UncaughtError} The error event converted to an Error object
+   */
+export function castErrorEvent (errorEvent) {
+  if (errorEvent.error instanceof SyntaxError && !/:\d+$/.test(errorEvent.error.stack?.trim())) {
+    const error = new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error.__newrelic)
+    error.name = SyntaxError.name
+    return error
+  }
+  if (canTrustError(errorEvent.error)) return errorEvent.error
+  return castError(errorEvent)
+}
+
+function canTrustError (error) {
+  return error instanceof Error && !!error.stack
+}

package/src/features/jserrors/{instrument → shared}/uncaught-error.js

@@ -1,3 +1,5 @@
+import { stringify } from '../../../common/util/stringify'
+
 /**
  * Represents an uncaught non Error type error. This class does
  * not extend the Error class to prevent an invalid stack trace
@@ -5,11 +7,12 @@
  * do not use the Error class (strings, etc) to an object.
  */
 export class UncaughtError {
-  constructor (message, filename, lineno, colno) {
+  constructor (message, filename, lineno, colno, newrelic) {
     this.name = 'UncaughtError'
-    this.message = message
+    this.message = typeof message === 'string' ? message : stringify(message)
     this.sourceURL = filename
     this.line = lineno
     this.column = colno
+    this.__newrelic = newrelic
   }
 }

package/src/features/session_trace/aggregate/index.js

@@ -44,6 +44,7 @@ export class Aggregate extends AggregateBase {
     this.trace = {}
     this.nodeCount = 0
     this.sentTrace = null
+    this.prevStoredEvents = new Set()
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000
     /**
@@ -108,7 +109,7 @@ export class Aggregate extends AggregateBase {
       this.isStandalone = true
       this.waitForFlags((['stn'])).then(([on]) => controlTraceOp(on), this.featureName, this.ee)
     } else {
-      registerHandler('errorAgg', () => {
+      registerHandler('trace-jserror', () => {
         seenAnError = true
         switchToFull()
       }, this.featureName, this.ee)
@@ -169,7 +170,7 @@ export class Aggregate extends AggregateBase {
     registerHandler('bstHist', (...args) => operationalGate.settle(() => this.storeHist(...args)), this.featureName, this.ee)
     registerHandler('bstXhrAgg', (...args) => operationalGate.settle(() => this.storeXhrAgg(...args)), this.featureName, this.ee)
     registerHandler('bstApi', (...args) => operationalGate.settle(() => this.storeSTN(...args)), this.featureName, this.ee)
-    registerHandler('errorAgg', (...args) => operationalGate.settle(() => this.storeErrorAgg(...args)), this.featureName, this.ee)
+    registerHandler('trace-jserror', (...args) => operationalGate.settle(() => this.storeErrorAgg(...args)), this.featureName, this.ee)
     registerHandler('pvtAdded', (...args) => operationalGate.settle(() => this.processPVT(...args)), this.featureName, this.ee)
     this.drain()
   }
@@ -208,6 +209,7 @@ export class Aggregate extends AggregateBase {
   }
 
   #prepareHarvest (options) {
+    this.prevStoredEvents.clear() // release references to past events for GC
     if (this.isStandalone) {
       if (this.ptid && now() >= MAX_TRACE_DURATION) {
         // Perform a final harvest once we hit or exceed the max session trace time
@@ -272,6 +274,8 @@ export class Aggregate extends AggregateBase {
   // Tracks the events and their listener's duration on objects wrapped by wrap-events.
   storeEvent (currentEvent, target, start, end) {
     if (this.shouldIgnoreEvent(currentEvent, target)) return
+    if (this.prevStoredEvents.has(currentEvent)) return // prevent multiple listeners of an event from creating duplicate trace nodes per occurrence. Cleared every harvest. near-zero chance for re-duplication after clearing per harvest since the timestamps of the event are considered for uniqueness.
+    this.prevStoredEvents.add(currentEvent)
 
     const evt = {
       n: this.evtName(currentEvent.type),

package/src/features/spa/aggregate/index.js

@@ -698,7 +698,7 @@ export class Aggregate extends AggregateBase {
       }
     }
 
-    baseEE.on('errorAgg', function (type, name, params, metrics) {
+    baseEE.on('spa-jserror', function (type, name, params, metrics) {
       if (!state.currentNode) return
       params._interactionId = state.currentNode.interaction.id
       // do not capture parentNodeId when in root node
@@ -707,6 +707,15 @@ export class Aggregate extends AggregateBase {
       }
     })
 
+    register('function-err', function (args, obj, error) {
+      if (!state.currentNode) return
+      error.__newrelic ??= {}
+      error.__newrelic[agentIdentifier] = { interactionId: state.currentNode.interaction.id }
+      if (state.currentNode.type && state.currentNode.type !== 'interaction') {
+        error.__newrelic[agentIdentifier].interactionNodeId = state.currentNode.id
+      }
+    }, this.featureName, baseEE)
+
     baseEE.on('interaction', saveInteraction)
 
     function getActionText (node) {

package/src/features/spa/instrument/index.js

@@ -10,6 +10,7 @@ import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
 import { isBrowserScope } from '../../../common/constants/runtime'
 import { now } from '../../../common/timing/now'
+import { handle } from '../../../common/event-emitter/handle'
 
 const {
   FEATURE_NAME, START, END, BODY, CB_END, JS_TIME, FETCH, FN_START, CB_START, FN_END
@@ -46,6 +47,8 @@ export class Instrument extends InstrumentBase {
     promiseEE.on(CB_END, endTimestamp)
     jsonpEE.on(CB_END, endTimestamp)
 
+    this.ee.on('fn-err', (...args) => { if (!args[2]?.__newrelic?.[agentIdentifier]) handle('function-err', [...args], undefined, this.featureName, this.ee) })
+
     this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName)
     eventsEE.buffer([FN_START], this.featureName)
     timerEE.buffer(['setTimeout' + END, 'clearTimeout' + START, FN_START], this.featureName)

package/src/features/utils/instrument-base.js

@@ -52,7 +52,7 @@ export class InstrumentBase extends FeatureBase {
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
     if (this.auto) registerDrain(agentIdentifier, featureName)
     else {
-      this.ee.on(`${this.featureName}-opt-in`, single(() => {
+      this.ee.on('manual-start-all', single(() => {
         // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
         // called by the api in that cycle
         registerDrain(this.agentIdentifier, this.featureName)

package/src/loaders/api/api.js

@@ -117,20 +117,10 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
     return appendJsAttribute('application.version', value, 'setApplicationVersion', false)
   }
 
-  apiInterface.start = (features) => {
+  apiInterface.start = () => {
     try {
-      const smTag = !features ? 'undefined' : 'defined'
-      handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/start/${smTag}/called`], undefined, FEATURE_NAMES.metrics, instanceEE)
-      const featNames = Object.values(FEATURE_NAMES)
-      if (features === undefined) features = featNames
-      else {
-        features = Array.isArray(features) && features.length ? features : [features]
-        if (features.some(f => !featNames.includes(f))) return warn(`Invalid feature name supplied. Acceptable feature names are: ${featNames}`)
-        if (!features.includes(FEATURE_NAMES.pageViewEvent)) features.push(FEATURE_NAMES.pageViewEvent)
-      }
-      features.forEach(feature => {
-        instanceEE.emit(`${feature}-opt-in`)
-      })
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
+      instanceEE.emit('manual-start-all')
     } catch (err) {
       warn('An unexpected issue occurred', err)
     }
@@ -166,9 +156,10 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
           try {
             return cb.apply(this, arguments)
           } catch (err) {
-            tracerEE.emit('fn-err', [arguments, this, err], contextStore)
+            const error = typeof err === 'string' ? new Error(err) : err
+            tracerEE.emit('fn-err', [arguments, this, error], contextStore)
             // the error came from outside the agent, so don't swallow
-            throw err
+            throw error
           } finally {
             tracerEE.emit('fn-end', [now()], contextStore)
           }

package/dist/types/features/jserrors/instrument/uncaught-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uncaught-error.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/uncaught-error.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACE,kEAMC;IALC,aAA2B;IAC3B,aAAsB;IACtB,eAAyB;IACzB,UAAkB;IAClB,YAAmB;CAEtB"}