@newrelic/browser-agent 1.274.0 → 1.276.0

package/dist/types/features/jserrors/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BAkCC;IA/BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,qBAAwB;IA6B1B,oDAEC;IAED;;;MAcC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED;;;;;;;;OAQG;IACH,gBAPW,KAAK,GAAC,aAAa,QACnB,MAAM,aACN,OAAO,YAAC,qBACR,MAAM,YAAC,cACP,OAAO,YAAC,QAqGlB;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAlQY,OAAO,0BAA0B,EAAE,SAAS;8BAP3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BAkCC;IA/BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,qBAAwB;IA6B1B,oDAEC;IAED;;;MAcC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED;;;;;;;;;OASG;IACH,gBARW,KAAK,GAAC,aAAa,QACnB,MAAM,aACN,OAAO,YAAC,qBACR,MAAM,YAAC,cACP,OAAO,YAAC,kBACR,MAAM,YAAC,QAqGjB;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAnQY,OAAO,0BAA0B,EAAE,SAAS;8BAP3B,4BAA4B"}

package/dist/types/features/jserrors/aggregate/internal-errors.d.ts

@@ -3,5 +3,5 @@
  * @param {Object} stackInfo - The error stack information.
  * @returns {boolean} - Whether the error should be swallowed or not.
  */
-export function evaluateInternalError(stackInfo: Object, internal: any): boolean;
+export function evaluateInternalError(stackInfo: Object, internal: any, reason: any): boolean;
 //# sourceMappingURL=internal-errors.d.ts.map

package/dist/types/features/jserrors/aggregate/internal-errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal-errors.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/internal-errors.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iDAHW,MAAM,kBACJ,OAAO,CA2BnB"}
+{"version":3,"file":"internal-errors.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/internal-errors.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iDAHW,MAAM,+BACJ,OAAO,CA2BnB"}

package/dist/types/features/metrics/aggregate/index.d.ts

@@ -6,7 +6,6 @@ export class Aggregate extends AggregateBase {
     singleChecks(): void;
     eachSessionChecks(): void;
     unload(): void;
-    resourcesSent: boolean | undefined;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/features/metrics/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IACjC,2BAuBC;IAED,wDAKC;IAED,iDAKC;IAED,qBAqEC;IAED,0BAOC;IAED,eAkCC;IA/BG,mCAAyB;CAgC9B;8BAlK6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IACjC,2BAuBC;IAED,wDAKC;IAED,iDAKC;IAED,qBAqEC;IAED,0BAOC;IAED,eAEC;CACF;8BAlI6B,4BAA4B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.274.0",
+  "version": "1.276.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -154,6 +154,17 @@
       "default": "./dist/esm/features/spa/instrument/index.js"
     }
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error",
+      "version": "22.11.0"
+    },
+    "packageManager": {
+      "name": "npm",
+      "onFail": "error"
+    }
+  },
   "engines": {
     "node": ">=12.17.0 < 13.0.0 || >=13.7.0"
   },
@@ -177,6 +188,7 @@
     "cdn:watch": "jung -r ./src -F '.*\\.test\\.js' --run -- npm run cdn:build:local",
     "test-server": "node ./tools/wdio/bin/server",
     "lt:update-browsers": "node ./tools/browsers-lists/lt-update-supported.mjs",
+    "lt:upload-webview-assets": "node ./tools/lambda-test/upload-webview-assets.mjs",
     "tools:test-builds": "npm --prefix ./tools/test-builds run build-all",
     "third-party-updates": "oss third-party manifest --includeOptDeps && oss third-party notices --includeOptDeps",
     "prepare": "husky install",

package/src/common/config/init.js

@@ -1,3 +1,4 @@
+import { FEATURE_FLAGS } from '../../features/generic_events/constants'
 import { LOG_LEVELS } from '../../features/logging/constants'
 import { isValidSelector } from '../dom/query-selector'
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../session/constants'
@@ -9,6 +10,12 @@ const nrMask = '[data-nr-mask]'
 
 const model = () => {
   const hiddenState = {
+    feature_flags: [],
+    experimental: {
+      marks: false,
+      measures: false,
+      resources: false
+    },
     mask_selector: '*',
     block_selector: '[data-nr-block]',
     mask_input_options: {
@@ -40,7 +47,8 @@ const model = () => {
       cors_use_tracecontext_headers: undefined,
       allowed_origins: undefined
     },
-    feature_flags: [],
+    get feature_flags () { return hiddenState.feature_flags },
+    set feature_flags (val) { hiddenState.feature_flags = val },
     generic_events: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
     harvest: { tooManyRequestsDelay: 60 },
     jserrors: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
@@ -51,8 +59,18 @@ const model = () => {
     page_view_event: { enabled: true, autoStart: true },
     page_view_timing: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
     performance: {
-      capture_marks: false,
-      capture_measures: false // false by default through experimental phase, but flipped to true once GA'd
+      get capture_marks () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.MARKS) || hiddenState.experimental.marks },
+      set capture_marks (val) { hiddenState.experimental.marks = val },
+      get capture_measures () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.MEASURES) || hiddenState.experimental.measures },
+      set capture_measures (val) { hiddenState.experimental.measures = val },
+      resources: {
+        // whether to run this subfeature or not in the generic_events feature. false by default through experimental phase, but flipped to true once GA'd
+        get enabled () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.RESOURCES) || hiddenState.experimental.resources },
+        set enabled (val) { hiddenState.experimental.resources = val },
+        asset_types: [], // MDN types to collect, empty array will collect all types
+        first_party_domains: [], // when included, will decorate the resource as first party if matching
+        ignore_newrelic: true // ignore capturing internal agent scripts and harvest calls
+      }
     },
     privacy: { cookies_enabled: true }, // *cli - per discussion, default should be true
     proxy: {

package/src/common/harvest/harvest.js

@@ -144,6 +144,25 @@ export class Harvest extends SharedContext {
         }
         cbFinished(cbResult)
       }, eventListenerOpts(false))
+    } else if (!opts.unload && cbFinished && submitMethod === submitData.xhrFetch) {
+      const harvestScope = this
+      result.then(async function (response) {
+        const status = response.status
+        const cbResult = { sent: true, status, fullUrl, fetchResponse: response }
+
+        if (response.status === 429) {
+          cbResult.retry = true
+          cbResult.delay = harvestScope.tooManyRequestsDelay
+        } else if (status === 408 || status === 500 || status === 503) {
+          cbResult.retry = true
+        }
+
+        if (opts.needResponse) {
+          cbResult.responseText = await response.text()
+        }
+
+        cbFinished(cbResult)
+      })
     }
 
     return result

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

@@ -17,11 +17,44 @@ import { isBrowserScope } from '../constants/runtime'
  * a final harvest within the agent.
  */
 export function getSubmitMethod ({ isFinalHarvest = false } = {}) {
-  return isFinalHarvest && isBrowserScope
+  if (isFinalHarvest && isBrowserScope) {
     // Use sendBeacon for final harvest
-    ? beacon
-    // If not final harvest, or not browserScope, always use xhr post
-    : xhr
+    return beacon
+  }
+
+  // If not final harvest, or not browserScope, use XHR post if available
+  if (typeof XMLHttpRequest !== 'undefined') {
+    return xhr
+  }
+
+  // Fallback for web workers where XMLHttpRequest is not available
+  return xhrFetch
+}
+
+/**
+ *
+ * @param url
+ * @param body
+ * @param method
+ * @param headers
+ * @returns {Promise<Response>}
+ */
+export function xhrFetch ({
+  url,
+  body = null,
+  method = 'POST',
+  headers = [{
+    key: 'content-type',
+    value: 'text/plain'
+  }]
+}) {
+  const objHeaders = {}
+
+  for (const header of headers) {
+    objHeaders[header.key] = header.value
+  }
+
+  return fetch(url, { headers: objHeaders, method, body, credentials: 'include' })
 }
 
 /**

package/src/common/wrap/wrap-events.js

@@ -37,8 +37,8 @@ export function wrapEvents (sharedEE) {
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {
     if (isBrowserScope) findEventListenerProtoAndCb(document, wrapNode)
+    if (XHR) findEventListenerProtoAndCb(XHR.prototype, wrapNode)
     findEventListenerProtoAndCb(globalScope, wrapNode)
-    findEventListenerProtoAndCb(XHR.prototype, wrapNode)
   }
 
   ee.on(ADD_EVENT_LISTENER + '-start', function (args, target) {

package/src/common/wrap/wrap-logger.js

@@ -10,7 +10,9 @@
 import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
 import { EventContext } from '../event-emitter/event-context'
 import { warn } from '../util/console'
-import { createWrapperWithEmitter as wfn } from './wrap-function'
+import { flag, createWrapperWithEmitter as wfn } from './wrap-function'
+
+const contextMap = new Map()
 
 /**
  * Wraps a supplied function and adds emitter events under the `-wrap-logger-` prefix
@@ -33,8 +35,11 @@ export function wrapLogger(sharedEE, parent, loggerFn, context) {
   ctx.level = context.level
   ctx.customAttributes = context.customAttributes
 
+  const contextLookupKey = parent[loggerFn]?.[flag] || parent[loggerFn]
+  contextMap.set(contextLookupKey, ctx)
+
   /** observe calls to <loggerFn> and emit events prefixed with `wrap-logger-` */
-  wrapFn.inPlace(parent, [loggerFn], 'wrap-logger-', ctx)
+  wrapFn.inPlace(parent, [loggerFn], 'wrap-logger-', () => contextMap.get(contextLookupKey))
 
   return ee
 }

package/src/common/wrap/wrap-xhr.js

@@ -28,6 +28,8 @@ export function wrapXhr (sharedEE) {
   var baseEE = sharedEE || contextualEE
   const ee = scopedEE(baseEE)
 
+  if (typeof globalScope.XMLHttpRequest === 'undefined') return ee
+
   // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
   // then we increment the count to track # of feats using this at runtime.
   if (wrapped[ee.debugId]++) return ee

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

@@ -374,7 +374,7 @@ function subscribeToEvents (agentRef, ee, handler, dt) {
     if (hasUndefinedHostname(params)) return // don't bother with XHR of url with no hostname
 
     metrics.duration = now() - this.startTime
-    if (!this.loadCazptureCalled && xhr.readyState === 4) {
+    if (!this.loadCaptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr)
     } else if (params.status == null) {
       params.status = 0

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

@@ -6,17 +6,17 @@ import { stringify } from '../../../common/util/stringify'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { cleanURL } from '../../../common/url/clean-url'
 import { FEATURE_NAME } from '../constants'
-import { initialLocation, isBrowserScope } from '../../../common/constants/runtime'
+import { globalScope, initialLocation, isBrowserScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { warn } from '../../../common/util/console'
 import { now } from '../../../common/timing/now'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { applyFnToProps } from '../../../common/util/traverse'
-import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
 import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator'
 import { isIFrameWindow } from '../../../common/dom/iframe'
+import { handle } from '../../../common/event-emitter/handle'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -35,6 +35,8 @@ export class Aggregate extends AggregateBase {
         return
       }
 
+      this.trackSupportabilityMetrics()
+
       if (agentRef.init.page_action.enabled) {
         registerHandler('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
@@ -72,11 +74,20 @@ export class Aggregate extends AggregateBase {
                 rageClick: aggregatedUserAction.rageClick,
                 target: aggregatedUserAction.selectorPath,
                 ...(isIFrameWindow(window) && { iframe: true }),
-                ...(target?.id && { targetId: target.id }),
-                ...(target?.tagName && { targetTag: target.tagName }),
-                ...(target?.type && { targetType: target.type }),
-                ...(target?.className && { targetClass: target.className })
+                ...(canTrustTargetAttribute('id') && { targetId: target.id }),
+                ...(canTrustTargetAttribute('tagName') && { targetTag: target.tagName }),
+                ...(canTrustTargetAttribute('type') && { targetType: target.type }),
+                ...(canTrustTargetAttribute('className') && { targetClass: target.className })
               })
+
+              /**
+               * Only trust attributes that exist on HTML element targets, which excludes the window and the document targets
+               * @param {string} attribute The attribute to check for on the target element
+               * @returns {boolean} Whether the target element has the attribute and can be trusted
+               */
+              function canTrustTargetAttribute (attribute) {
+                return !!(aggregatedUserAction.selectorPath !== 'window' && aggregatedUserAction.selectorPath !== 'document' && target instanceof HTMLElement && target?.[attribute])
+              }
             }
           } catch (e) {
             // do nothing for now
@@ -104,10 +115,11 @@ export class Aggregate extends AggregateBase {
               const observer = new PerformanceObserver((list) => {
                 list.getEntries().forEach(entry => {
                   try {
+                    handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/' + type + '/Seen'])
                     this.addEvent({
                       eventType: 'BrowserPerformance',
                       timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entry.startTime)),
-                      entryName: entry.name,
+                      entryName: cleanURL(entry.name),
                       entryDuration: entry.duration,
                       entryType: type,
                       ...(entry.detail && { entryDetail: entry.detail })
@@ -124,6 +136,47 @@ export class Aggregate extends AggregateBase {
         }
       }
 
+      if (isBrowserScope && agentRef.init.performance.resources.enabled) {
+        registerHandler('browserPerformance.resource', (entry) => {
+          try {
+            // convert the entry to a plain object and separate the name and duration from the object
+            // you need to do this to be able to spread it into the addEvent call later, and name and duration
+            // would be duplicative of entryName and entryDuration and are protected keys in NR1
+            const { name, duration, ...entryObject } = entry.toJSON()
+
+            let firstParty = false
+            try {
+              const entryDomain = new URL(name).hostname
+              const isNr = (entryDomain.includes('newrelic.com') || entryDomain.includes('nr-data.net') || entryDomain.includes('nr-local.net'))
+              /** decide if we should ignore nr-specific assets */
+              if (this.agentRef.init.performance.resources.ignore_newrelic && isNr) return
+              /** decide if we should ignore the asset type (empty means allow everything, which is the default) */
+              if (this.agentRef.init.performance.resources.asset_types.length && !this.agentRef.init.performance.resources.asset_types.includes(entryObject.initiatorType)) return
+              /** decide if the entryDomain is a first party domain */
+              firstParty = entryDomain === globalScope?.location.hostname || agentRef.init.performance.resources.first_party_domains.includes(entryDomain)
+              if (firstParty) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/FirstPartyResource/Seen'])
+              if (isNr) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/NrResource/Seen'])
+            } catch (err) {
+            // couldnt parse the URL, so firstParty will just default to false
+            }
+
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/Resource/Seen'])
+            const event = {
+              ...entryObject,
+              eventType: 'BrowserPerformance',
+              timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entryObject.startTime)),
+              entryName: name,
+              entryDuration: duration,
+              firstParty
+            }
+
+            this.addEvent(event)
+          } catch (err) {
+            this.ee.emit('internal-error', [err, 'GenericEvents-Resource'])
+          }
+        }, this.featureName, this.ee)
+      }
+
       this.harvestScheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
         onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
         onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
@@ -177,9 +230,16 @@ export class Aggregate extends AggregateBase {
       ...obj
     }
 
-    this.events.add(eventAttributes)
-
-    this.checkEventLimits()
+    const addedEvent = this.events.add(eventAttributes)
+    if (!addedEvent && !this.events.isEmpty()) {
+      /** could not add the event because it pushed the buffer over the limit
+       * so we harvest early, and try to add it again now that the buffer is cleared
+       * if it fails again, we do nothing
+       */
+      this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen'])
+      this.harvestScheduler.runHarvest()
+      this.events.add(eventAttributes)
+    }
   }
 
   serializer (eventBuffer) {
@@ -190,11 +250,14 @@ export class Aggregate extends AggregateBase {
     return { ua: this.agentRef.info.userAttributes, at: this.agentRef.info.atts }
   }
 
-  checkEventLimits () {
-    // check if we've reached any harvest limits...
-    if (this.events.byteSize() > IDEAL_PAYLOAD_SIZE) {
-      this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen'])
-      this.harvestScheduler.runHarvest()
-    }
+  trackSupportabilityMetrics () {
+    /** track usage SMs to improve these experimental features */
+    const configPerfTag = 'Config/Performance/'
+    if (this.agentRef.init.performance.capture_marks) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMarks/Enabled'])
+    if (this.agentRef.init.performance.capture_measures) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMeasures/Enabled'])
+    if (this.agentRef.init.performance.resources.enabled) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/Enabled'])
+    if (this.agentRef.init.performance.resources.asset_types?.length !== 0) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/AssetTypes/Changed'])
+    if (this.agentRef.init.performance.resources.first_party_domains?.length !== 0) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/FirstPartyDomains/Changed'])
+    if (this.agentRef.init.performance.resources.ignore_newrelic === false) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/IgnoreNewrelic/Changed'])
   }
 }

package/src/features/generic_events/constants.js

@@ -9,3 +9,9 @@ export const OBSERVED_WINDOW_EVENTS = ['focus', 'blur']
 
 export const RAGE_CLICK_THRESHOLD_EVENTS = 4
 export const RAGE_CLICK_THRESHOLD_MS = 1000
+
+export const FEATURE_FLAGS = {
+  MARKS: 'experimental.marks',
+  MEASURES: 'experimental.measures',
+  RESOURCES: 'experimental.resources'
+}

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

@@ -2,7 +2,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { isBrowserScope } from '../../../common/constants/runtime'
+import { globalScope, isBrowserScope } from '../../../common/constants/runtime'
 import { handle } from '../../../common/event-emitter/handle'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { InstrumentBase } from '../../utils/instrument-base'
@@ -12,22 +12,33 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto)
+    /** config values that gate whether the generic events aggregator should be imported at all */
     const genericEventSourceConfigs = [
       agentRef.init.page_action.enabled,
       agentRef.init.performance.capture_marks,
       agentRef.init.performance.capture_measures,
-      agentRef.init.user_actions.enabled
-      // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
+      agentRef.init.user_actions.enabled,
+      agentRef.init.performance.resources.enabled
     ]
 
-    if (isBrowserScope && agentRef.init.user_actions.enabled) {
-      OBSERVED_EVENTS.forEach(eventType =>
-        windowAddEventListener(eventType, (evt) => handle('ua', [evt], undefined, this.featureName, this.ee), true)
-      )
-      OBSERVED_WINDOW_EVENTS.forEach(eventType =>
-        windowAddEventListener(eventType, (evt) => handle('ua', [evt], undefined, this.featureName, this.ee))
+    if (isBrowserScope) {
+      if (agentRef.init.user_actions.enabled) {
+        OBSERVED_EVENTS.forEach(eventType =>
+          windowAddEventListener(eventType, (evt) => handle('ua', [evt], undefined, this.featureName, this.ee), true)
+        )
+        OBSERVED_WINDOW_EVENTS.forEach(eventType =>
+          windowAddEventListener(eventType, (evt) => handle('ua', [evt], undefined, this.featureName, this.ee))
         // Capture is not used here so that we don't get element focus/blur events, only the window's as they do not bubble. They are also not cancellable, so no worries about being front of line.
-      )
+        )
+      }
+      if (agentRef.init.performance.resources.enabled && globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
+        const observer = new PerformanceObserver((list) => {
+          list.getEntries().forEach(entry => {
+            handle('browserPerformance.resource', [entry], undefined, this.featureName, this.ee)
+          })
+        })
+        observer.observe({ type: 'resource', buffered: true })
+      }
     }
 
     /** If any of the sources are active, import the aggregator. otherwise deregister */

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

@@ -114,9 +114,10 @@ export class Aggregate extends AggregateBase {
    * @param {boolean=} internal if the error was "caught" and deemed "internal" before reporting to the jserrors feature
    * @param {object=} customAttributes  any custom attributes to be included in the error payload
    * @param {boolean=} hasReplay a flag indicating if the error occurred during a replay session
+   * @param {string=} swallowReason a string indicating pre-defined reason if swallowing the error.  Mainly used by the internal error SMs.
    * @returns
    */
-  storeError (err, time, internal, customAttributes, hasReplay) {
+  storeError (err, time, internal, customAttributes, hasReplay, swallowReason) {
     if (!err) return
     // are we in an interaction
     time = time || now()
@@ -134,7 +135,7 @@ export class Aggregate extends AggregateBase {
 
     var stackInfo = computeStackTrace(err)
 
-    const { shouldSwallow, reason } = evaluateInternalError(stackInfo, internal)
+    const { shouldSwallow, reason } = evaluateInternalError(stackInfo, internal, swallowReason)
     if (shouldSwallow) {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['Internal/Error/' + reason], undefined, FEATURE_NAMES.metrics, this.ee)
       return

package/src/features/jserrors/aggregate/internal-errors.js

@@ -5,8 +5,8 @@ const REASON_SECURITY_POLICY = 'Security-Policy'
  * @param {Object} stackInfo - The error stack information.
  * @returns {boolean} - Whether the error should be swallowed or not.
  */
-export function evaluateInternalError (stackInfo, internal) {
-  const output = { shouldSwallow: internal || false, reason: 'Other' }
+export function evaluateInternalError (stackInfo, internal, reason) {
+  const output = { shouldSwallow: internal || false, reason: reason || 'Other' }
   const leadingFrame = stackInfo.frames?.[0]
   /** If we cant otherwise determine from the frames and message, the default of internal + reason will be the fallback */
   if (!leadingFrame || typeof stackInfo?.message !== 'string') return output

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

@@ -24,9 +24,9 @@ export class Instrument extends InstrumentBase {
       this.removeOnAbort = new AbortController()
     } catch (e) {}
 
-    this.ee.on('internal-error', (error) => {
+    this.ee.on('internal-error', (error, reason) => {
       if (!this.abortHandler) return
-      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee)
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning, reason], undefined, this.featureName, this.ee)
     })
 
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {

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

@@ -134,38 +134,6 @@ export class Aggregate extends AggregateBase {
   }
 
   unload () {
-    try {
-      if (this.resourcesSent) return
-      this.resourcesSent = true // make sure this only gets sent once
-
-      // Capture SMs around network resources using the performance API to assess
-      // work to split this out from the ST nodes
-      // differentiate between internal+external and ajax+non-ajax
-      const ajaxResources = ['beacon', 'fetch', 'xmlhttprequest']
-      const internalUrls = ['nr-data.net', 'newrelic.com', 'nr-local.net', 'localhost']
-      function isInternal (x) { return internalUrls.some(y => x.name.indexOf(y) >= 0) }
-      function isAjax (x) { return ajaxResources.includes(x.initiatorType) }
-      const allResources = performance?.getEntriesByType('resource') || []
-      allResources.forEach((entry) => {
-        if (isInternal(entry)) {
-          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/Internal')
-          else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/Internal')
-        } else {
-          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/External')
-          else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/External')
-        }
-      })
-
-      // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
-      // data in the agent for use in NR
-      if (typeof performance !== 'undefined') {
-        const markers = performance.getEntriesByType('mark')
-        const measures = performance.getEntriesByType('measure')
-        if (markers.length) this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length)
-        if (measures.length) this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length)
-      }
-    } catch (e) {
-      // do nothing
-    }
+    // do nothing for now, marks and measures and resources stats are now being captured by the ge feature
   }
 }