@newrelic/browser-agent 1.290.1 → 1.291.1

package/src/common/util/console.js

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { dispatchGlobalEvent } from '../dispatch/global-event'
+
 /* eslint no-console: ["error", { allow: ["debug"] }] */
 
 /**
@@ -14,4 +16,15 @@
 export function warn (code, secondary) {
   if (typeof console.debug !== 'function') return
   console.debug(`New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#${code}`, secondary)
+  dispatchGlobalEvent({
+    agentIdentifier: null,
+    drained: null,
+    type: 'data',
+    name: 'warn',
+    feature: 'warn',
+    data: {
+      code,
+      secondary
+    }
+  })
 }

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

@@ -143,7 +143,7 @@ export class Aggregate extends AggregateBase {
                       ...detailObj,
                       eventType: 'BrowserPerformance',
                       timestamp: this.toEpoch(entry.startTime),
-                      entryName: cleanURL(entry.name),
+                      entryName: entry.name,
                       entryDuration: entry.duration,
                       entryType: type
                     })
@@ -208,7 +208,7 @@ export class Aggregate extends AggregateBase {
               ...entryObject,
               eventType: 'BrowserPerformance',
               timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entryObject.startTime)),
-              entryName: name,
+              entryName: cleanURL(name),
               entryDuration: duration,
               firstParty
             }
@@ -220,6 +220,21 @@ export class Aggregate extends AggregateBase {
         }, this.featureName, this.ee)
       }
 
+      registerHandler('api-measure', (args, n) => {
+        const { start, duration, customAttributes } = args
+
+        const event = {
+          ...customAttributes,
+          eventType: 'BrowserPerformance',
+          timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(start)),
+          entryName: n,
+          entryDuration: duration,
+          entryType: 'measure'
+        }
+
+        this.addEvent(event)
+      }, this.featureName, this.ee)
+
       agentRef.runtime.harvester.triggerHarvestFor(this)
       this.drain()
     })

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

@@ -11,6 +11,7 @@ import { setupAddPageActionAPI } from '../../../loaders/api/addPageAction'
 import { setupFinishedAPI } from '../../../loaders/api/finished'
 import { setupRecordCustomEventAPI } from '../../../loaders/api/recordCustomEvent'
 import { setupRegisterAPI } from '../../../loaders/api/register'
+import { setupMeasureAPI } from '../../../loaders/api/measure'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME, OBSERVED_EVENTS, OBSERVED_WINDOW_EVENTS } from '../constants'
 
@@ -32,6 +33,7 @@ export class Instrument extends InstrumentBase {
     setupRecordCustomEventAPI(agentRef)
     setupFinishedAPI(agentRef)
     setupRegisterAPI(agentRef)
+    setupMeasureAPI(agentRef)
 
     if (isBrowserScope) {
       if (agentRef.init.user_actions.enabled) {

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

@@ -262,6 +262,10 @@ export class Aggregate extends AggregateBase {
     if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this)
     payloadOutput.payload = payload
 
+    if (!this.agentRef.runtime.session.state.traceHarvestStarted) {
+      warn(59, JSON.stringify(this.agentRef.runtime.session.state))
+    }
+
     return [payloadOutput]
   }
 

package/src/features/session_replay/shared/recorder.js

@@ -155,10 +155,6 @@ export class Recorder {
   /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
   store (event, isCheckout) {
     if (!event) return
-    if (this.parent.agentRef.runtime.session?.isAfterSessionExpiry(event.timestamp)) {
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Session/Expired/SessionReplay/Seen'], undefined, FEATURE_NAMES.metrics, this.ee)
-      return
-    }
 
     if (!(this.parent instanceof AggregateBase) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1]
     else this.currentBufferTarget = this.#events

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

@@ -11,6 +11,7 @@ import { globalScope } from '../../../common/constants/runtime'
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { cleanURL } from '../../../common/url/clean-url'
+import { warn } from '../../../common/util/console'
 
 const ERROR_MODE_SECONDS_WINDOW = 30 * 1000 // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
 /** Reserved room for query param attrs */
@@ -85,7 +86,7 @@ export class Aggregate extends AggregateBase {
     registerHandler('bstResource', (...args) => this.events.storeResources(...args), this.featureName, this.ee)
     registerHandler('bstHist', (...args) => this.events.storeHist(...args), this.featureName, this.ee)
     registerHandler('bstXhrAgg', (...args) => this.events.storeXhrAgg(...args), this.featureName, this.ee)
-    registerHandler('bstApi', (...args) => this.events.storeSTN(...args), this.featureName, this.ee)
+    registerHandler('bstApi', (...args) => this.events.storeNode(...args), this.featureName, this.ee)
     registerHandler('trace-jserror', (...args) => this.events.storeErrorAgg(...args), this.featureName, this.ee)
     registerHandler('pvtAdded', (...args) => this.events.processPVT(...args), this.featureName, this.ee)
 
@@ -97,10 +98,12 @@ export class Aggregate extends AggregateBase {
     }
     this.agentRef.runtime.session.write({ sessionTraceMode: this.mode })
     this.drain()
+    /** try to harvest immediately. This will not send if the trace is not running in FULL mode due to the pre-harvest checks. */
+    this.agentRef.runtime.harvester.triggerHarvestFor(this)
   }
 
   preHarvestChecks () {
-    if (this.mode !== MODE.FULL) return // only allow harvest if running in full mode
+    if (this.blocked || this.mode !== MODE.FULL) return // only allow harvest if running in full mode
     if (!this.timeKeeper?.ready) return // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
     if (!this.agentRef.runtime.session) return // session entity is required for trace to run and continue running
     if (this.sessionId !== this.agentRef.runtime.session.state.value || this.ptid !== this.agentRef.runtime.ptid) {
@@ -178,7 +181,8 @@ export class Aggregate extends AggregateBase {
   }
 
   /** Stop running for the remainder of the page lifecycle */
-  abort () {
+  abort (code) {
+    warn(60, code)
     this.blocked = true
     this.mode = MODE.OFF
     this.agentRef.runtime.session.write({ sessionTraceMode: this.mode })

package/src/features/session_trace/aggregate/trace/storage.js

@@ -41,23 +41,18 @@ export class TraceStorage {
     this.parent = parent
   }
 
-  isAfterSessionExpiry (entryTimestamp) {
-    return this.parent.agentRef.runtime?.session?.isAfterSessionExpiry((this.parent.timeKeeper?.ready && this.parent.timeKeeper.convertRelativeTimestamp(entryTimestamp)) ?? undefined)
-  }
-
-  /** Central function called by all the other store__ & addToTrace API to append a trace node. */
-  storeSTN (stn) {
-    if (this.parent.blocked) return
+  #canStoreNewNode () {
+    if (this.parent.blocked) return false
     if (this.nodeCount >= MAX_NODES_PER_HARVEST) { // limit the amount of pending data awaiting next harvest
-      if (this.parent.mode !== MODE.ERROR) return
+      if (this.parent.mode !== MODE.ERROR) return false
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW) // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
-      if (openedSpace === 0) return
-    }
-    if (this.isAfterSessionExpiry(stn.s)) {
-      this.parent.reportSupportabilityMetric('Session/Expired/SessionTrace/Seen')
-      return
+      if (openedSpace === 0) return false
     }
+    return true
+  }
 
+  /** Central internal function called by all the other store__ & addToTrace API to append a trace node. They MUST all have checked #canStoreNewNode before calling this func!! */
+  #storeSTN (stn) {
     if (this.trace[stn.n]) this.trace[stn.n].push(stn)
     else this.trace[stn.n] = [stn]
 
@@ -143,6 +138,11 @@ export class TraceStorage {
     }
   }
 
+  storeNode (node) {
+    if (!this.#canStoreNewNode()) return
+    this.#storeSTN(node)
+  }
+
   processPVT (name, value, attrs) {
     this.storeTiming({ [name]: value })
   }
@@ -168,13 +168,16 @@ export class TraceStorage {
           Math.floor(this.parent.timeKeeper.correctAbsoluteTimestamp(val))
         )
       }
-      this.storeSTN(new TraceNode(key, val, val, 'document', 'timing'))
+      if (!this.#canStoreNewNode()) return // at any point when no new nodes can be stored, there's no point in processing the rest of the timing entries
+      this.#storeSTN(new TraceNode(key, val, val, 'document', 'timing'))
     }
   }
 
   // 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.#canStoreNewNode()) return // need to check if adding node will succeed BEFORE storing event ref below (*cli Jun'25 - addressing memory leak in aborted ST issue #NR-420780)
+
     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)
 
@@ -186,7 +189,7 @@ export class TraceStorage {
     } catch (e) {
       evt.o = eventOrigin(null, target, this.parent.ee)
     }
-    this.storeSTN(evt)
+    this.#storeSTN(evt)
   }
 
   shouldIgnoreEvent (event, target) {
@@ -224,7 +227,8 @@ export class TraceStorage {
 
   // Tracks when the window history API specified by wrap-history is used.
   storeHist (path, old, time) {
-    this.storeSTN(new TraceNode('history.pushState', time, time, path, old))
+    if (!this.#canStoreNewNode()) return
+    this.#storeSTN(new TraceNode('history.pushState', time, time, path, old))
   }
 
   #laststart = 0
@@ -232,14 +236,17 @@ export class TraceStorage {
   storeResources (resources) {
     if (!resources || resources.length === 0) return
 
-    resources.forEach((currentResource) => {
-      if ((currentResource.fetchStart | 0) <= this.#laststart) return // don't recollect already-seen resources
+    for (let i = 0; i < resources.length; i++) {
+      const currentResource = resources[i]
+      if ((currentResource.fetchStart | 0) <= this.#laststart) continue // don't recollect already-seen resources
+      if (!this.#canStoreNewNode()) break // stop processing if we can't store any more resource nodes anyways
 
       const { initiatorType, fetchStart, responseEnd, entryType } = currentResource
       const { protocol, hostname, port, pathname } = parseUrl(currentResource.name)
       const res = new TraceNode(initiatorType, fetchStart | 0, responseEnd | 0, `${protocol}://${hostname}:${port}${pathname}`, entryType)
-      this.storeSTN(res)
-    })
+
+      this.#storeSTN(res)
+    }
 
     this.#laststart = resources[resources.length - 1].fetchStart | 0
   }
@@ -247,13 +254,15 @@ export class TraceStorage {
   // JavascriptError (FEATURE) events pipes into ST here.
   storeErrorAgg (type, name, params, metrics) {
     if (type !== 'err') return // internal errors are purposefully ignored
-    this.storeSTN(new TraceNode('error', metrics.time, metrics.time, params.message, params.stackHash))
+    if (!this.#canStoreNewNode()) return
+    this.#storeSTN(new TraceNode('error', metrics.time, metrics.time, params.message, params.stackHash))
   }
 
   // Ajax (FEATURE) events--XML & fetches--pipes into ST here.
   storeXhrAgg (type, name, params, metrics) {
     if (type !== 'xhr') return
-    this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, `${params.status} ${params.method}: ${params.host}${params.pathname}`, 'ajax'))
+    if (!this.#canStoreNewNode()) return
+    this.#storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, `${params.status} ${params.method}: ${params.host}${params.pathname}`, 'ajax'))
   }
 
   /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace shared with AggregateBase.
@@ -279,7 +288,12 @@ export class TraceStorage {
   }
 
   reloadSave () {
-    Object.values(this.#backupTrace).forEach(stnsArray => stnsArray.forEach(stn => this.storeSTN(stn)))
+    for (const stnsArray of Object.values(this.#backupTrace)) {
+      for (const stn of stnsArray) {
+        if (!this.#canStoreNewNode()) return // stop attempting to re-store nodes
+        this.#storeSTN(stn)
+      }
+    }
   }
 
   clearSave () {

package/src/loaders/api/addToTrace.js

@@ -4,6 +4,7 @@
  */
 import { originTime } from '../../common/constants/runtime'
 import { handle } from '../../common/event-emitter/handle'
+import { warn } from '../../common/util/console'
 import { FEATURE_NAMES } from '../features/features'
 import { ADD_TO_TRACE } from './constants'
 import { setupAPI } from './sharedHandlers'
@@ -20,6 +21,11 @@ export function setupAddToTraceAPI (agent) {
       t: 'api'
     }
 
+    if (report.s < 0 || report.e < 0 || report.e < report.s) {
+      warn(61, { start: report.s, end: report.e })
+      return
+    }
+
     handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, agent.ee)
   }, agent)
 }

package/src/loaders/api/constants.js

@@ -24,3 +24,4 @@ export const SET_PAGE_VIEW_NAME = 'setPageViewName'
 export const SET_USER_ID = 'setUserId'
 export const START = 'start'
 export const WRAP_LOGGER = 'wrapLogger'
+export const MEASURE = 'measure'

package/src/loaders/api/measure.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { handle } from '../../common/event-emitter/handle'
+import { now } from '../../common/timing/now'
+import { warn } from '../../common/util/console'
+import { FEATURE_NAMES } from '../features/features'
+import { prefix, MEASURE } from './constants'
+import { setupAPI } from './sharedHandlers'
+
+export function setupMeasureAPI (agent) {
+  setupAPI(MEASURE, function (name, options) {
+    const n = now()
+    const { start, end, customAttributes } = options || {}
+    const returnObj = { customAttributes: customAttributes || {} }
+
+    if (typeof returnObj.customAttributes !== 'object' || typeof name !== 'string' || name.length === 0) {
+      warn(57)
+      return
+    }
+
+    /**
+     * getValueFromTiming - Helper function to extract a numeric value from a supplied option.
+     * @param {Number|PerformanceMark} [timing] The timing value
+     * @param {Number} [d] The default value to return if timing is invalid
+     * @returns {Number} The timing value or the default value
+     */
+    const getValueFromTiming = (timing, d) => {
+      if (timing == null) return d
+      if (typeof timing === 'number') return timing
+      if (timing instanceof PerformanceMark) return timing.startTime
+      return Number.NaN
+    }
+
+    returnObj.start = getValueFromTiming(start, 0)
+    returnObj.end = getValueFromTiming(end, n)
+    if (Number.isNaN(returnObj.start) || Number.isNaN(returnObj.end)) {
+      warn(57)
+      return
+    }
+
+    returnObj.duration = returnObj.end - returnObj.start
+    if (returnObj.duration < 0) {
+      warn(58)
+      return
+    }
+
+    handle(prefix + MEASURE, [returnObj, name], undefined, FEATURE_NAMES.genericEvents, agent.ee)
+
+    return returnObj
+  }, agent)
+}

package/src/loaders/api-base.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { warn } from '../common/util/console'
-import { ADD_PAGE_ACTION, ADD_RELEASE, ADD_TO_TRACE, FINISHED, INTERACTION, LOG, NOTICE_ERROR, PAUSE_REPLAY, RECORD_CUSTOM_EVENT, RECORD_REPLAY, REGISTER, SET_APPLICATION_VERSION, SET_CURRENT_ROUTE_NAME, SET_CUSTOM_ATTRIBUTE, SET_ERROR_HANDLER, SET_PAGE_VIEW_NAME, SET_USER_ID, START, WRAP_LOGGER } from './api/constants'
+import { ADD_PAGE_ACTION, ADD_RELEASE, ADD_TO_TRACE, FINISHED, INTERACTION, LOG, NOTICE_ERROR, PAUSE_REPLAY, RECORD_CUSTOM_EVENT, RECORD_REPLAY, REGISTER, SET_APPLICATION_VERSION, SET_CURRENT_ROUTE_NAME, SET_CUSTOM_ATTRIBUTE, SET_ERROR_HANDLER, SET_PAGE_VIEW_NAME, SET_USER_ID, START, WRAP_LOGGER, MEASURE } from './api/constants'
 
 /**
  * @typedef {import('./api/interaction-types').InteractionInstance} InteractionInstance
@@ -215,4 +215,15 @@ export class ApiBase {
   wrapLogger (parent, functionName, options) {
     return this.#callMethod(WRAP_LOGGER, parent, functionName, options)
   }
+
+  /**
+   * Measures a task that is recorded as a BrowserPerformance event.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/measure/}
+   * @param {string} name The name of the task
+   * @param {object?} options An object used to control the way the measure API operates
+   * @returns {{start: number, end: number, duration: number, customAttributes: object}} Measurement details
+   */
+  measure (name, options) {
+    return this.#callMethod(MEASURE, name, options)
+  }
 }