@newrelic/browser-agent 1.318.0 → 1.319.0-rc.0

package/dist/types/common/util/console.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/common/util/console.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,4CAHW,GAAC,QAgBX"}
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/common/util/console.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAEH,2BALW,MAAM,cACN,GAAC,QAiBX"}

package/dist/types/common/v2/mfe-vitals.d.ts

@@ -1,14 +1,11 @@
 /**
  * Tracks all Core Web Vitals for a specific MFE.
- * @param {string} id - The MFE ID to track
- * @returns {{fcp: object|null, lcp: object|null, cls: object|null, inp: object|null, disconnect: Function}}
+ * @param {RegisterAPITarget} target - The MFE target to track vitals for
+ * @param {RegisterAPITimings} timings - The timings object to use for relative time calculations
+ * @returns {RegisterAPIVitals} An object containing the vitals values and a disconnect method to stop tracking
  */
-export function trackMFEVitals(id: string, timings: any): {
-    fcp: object | null;
-    lcp: object | null;
-    cls: object | null;
-    inp: object | null;
-    disconnect: Function;
-};
-export type RegisterAPITimings = any;
+export function trackMFEVitals(target: RegisterAPITarget, timings: RegisterAPITimings): RegisterAPIVitals;
+export type RegisterAPITimings = import("../../loaders/api/register-api-types").RegisterAPITimings;
+export type RegisterAPITarget = import("../../loaders/api/register-api-types").RegisterAPITarget;
+export type RegisterAPIVitals = import("../../loaders/api/register-api-types").RegisterAPIVitals;
 //# sourceMappingURL=mfe-vitals.d.ts.map

package/dist/types/common/v2/mfe-vitals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mfe-vitals.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/mfe-vitals.js"],"names":[],"mappings":"AA+FA;;;;GAIG;AACH,mCAHW,MAAM,iBACJ;IAAC,GAAG,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,UAAU,WAAU;CAAC,CA0L1G"}
+{"version":3,"file":"mfe-vitals.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/mfe-vitals.js"],"names":[],"mappings":"AAoHA;;;;;GAKG;AACH,uCAJW,iBAAiB,WACjB,kBAAkB,GAChB,iBAAiB,CAqM7B;iCApTY,OAAO,sCAAsC,EAAE,kBAAkB;gCACjE,OAAO,sCAAsC,EAAE,iBAAiB;gCAChE,OAAO,sCAAsC,EAAE,iBAAiB"}

package/dist/types/common/wrap/wrap-websocket.d.ts

@@ -1,2 +1,2 @@
-export function wrapWebSocket(sharedEE: any): any;
+export function wrapWebSocket(sharedEE: any, agentRef: any): any;
 //# sourceMappingURL=wrap-websocket.d.ts.map

package/dist/types/common/wrap/wrap-websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-websocket.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-websocket.js"],"names":[],"mappings":"AAeA,kDA2IC"}
+{"version":3,"file":"wrap-websocket.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-websocket.js"],"names":[],"mappings":"AAgBA,iEA4IC"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAAiC;IAEjC,2BA6BC;IAvBC,uBAA4D;IAyB9D,0GAqFC;IAED,+CAOC;IAED,iDAoEC;CACF;8BAjN6B,4BAA4B;2BAK/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAAiC;IAEjC,2BA6BC;IAvBC,uBAA4D;IAyB9D,0GA2FC;IAED,+CAOC;IAED,iDAoEC;CACF;8BAvN6B,4BAA4B;2BAK/B,gCAAgC"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAmBA;IACE,2BAAiC;IAGjC,2BA6QC;IA3QC,gCAAkG;IAIlG,uBAA0C;IA0Q5C;;;;;;;;;;;;OAYG;IACH,eAJW,MAAM,YAAC,WACP,MAAM,YAAC,QAkCjB;IAED,6CAEC;IAED;;;MAEC;;CAsBF;8BAzW6B,4BAA4B;2BAI/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAmBA;IACE,2BAAiC;IAGjC,2BA+QC;IA7QC,gCAAkG;IAIlG,uBAA0C;IA4Q5C;;;;;;;;;;;;OAYG;IACH,eAJW,MAAM,YAAC,WACP,MAAM,YAAC,QAkCjB;IAED,6CAEC;IAED;;;MAEC;;CAsBF;8BA3W6B,4BAA4B;2BAI/B,gCAAgC"}

package/dist/types/loaders/api/register-api-types.d.ts

@@ -146,4 +146,22 @@ export type RegisterAPITimings = {
      */
     type: string;
 };
+export type RegisterAPIVitals = {
+    /**
+     * - The first contentful paint timing for the registered entity.
+     */
+    fcp?: number | undefined;
+    /**
+     * - The largest contentful paint timing for the registered entity.
+     */
+    lcp?: number | undefined;
+    /**
+     * - The cumulative layout shift score for the registered entity.
+     */
+    cls?: number | undefined;
+    /**
+     * - The interaction to next paint timing for the registered entity.
+     */
+    inp?: number | undefined;
+};
 //# sourceMappingURL=register-api-types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.318.0",
+  "version": "1.319.0-rc.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -176,6 +176,8 @@
     "start": "npm-run-all --parallel cdn:watch test-server",
     "lint": "eslint -c .eslintrc.js --ext .js,.cjs,.mjs .",
     "lint:fix": "npm run lint -- --fix",
+    "generate:warning-codes": "node tools/warning-codes/generate-jsdoc.js",
+    "check:warning-codes": "node tools/warning-codes/check-usage.js",
     "test": " NODE_OPTIONS=--max-old-space-size=8192 jest",
     "test:unit": "jest --selectProjects unit",
     "test:component": "jest --selectProjects component",
@@ -284,4 +286,4 @@
     "README.md",
     "CHANGELOG.md"
   ]
-}
+}

package/src/common/payloads/payloads.js

@@ -8,13 +8,31 @@ import { CAPTURE_PAYLOAD_SETTINGS } from '../../features/ajax/constants'
 
 /**
  * Determines whether payload data should be captured based on the capture mode setting,
- * HTTP status code, and GraphQL error status.
+ * HTTP status code, and GraphQL error status.  Will never capture agent's own payloads.
  * @param {string} captureMode - The capture mode setting ('none', 'all', or 'failures')
- * @param {number} statusCode - The HTTP status code
- * @param {boolean} hasGQLErrors - Whether the response contains GraphQL errors
+ * @param {Object} event - An object representing the AJAX event
+ * @param {number} event.statusCode - The HTTP status code
+ * @param {boolean} event.hasGQLErrors - Whether the response contains GraphQL errors
+ * @param {string} event.payloadHost - The host of the AJAX payload (includes port)
+ * @param {string} event.payloadHostname - The hostname of the AJAX payload
+ * @param {string} [event.payloadPathname=''] - The pathname of the AJAX payload
+ * @param {string[]} [beacons=[]] - Array of beacon hostnames to avoid capturing
  * @returns {boolean} True if payload should be captured
  */
-export function canCapturePayload (captureMode, statusCode, hasGQLErrors) {
+export function canCapturePayload (captureMode, {
+  statusCode,
+  hasGQLErrors,
+  payloadHost,
+  payloadHostname,
+  payloadPathname = ''
+}, beacons = []) {
+  if (payloadHostname) {
+    const payloadUrl = payloadHostname + payloadPathname
+    const payloadUrlWithPort = payloadHost + payloadPathname
+    if (beacons.some((b) => {
+      return b === payloadUrl || payloadUrl.startsWith(b + '/') || b === payloadUrlWithPort || payloadUrlWithPort.startsWith(b + '/')
+    })) return false
+  }
   if (captureMode === CAPTURE_PAYLOAD_SETTINGS.ALL) return true
   if (!captureMode || captureMode === CAPTURE_PAYLOAD_SETTINGS.NONE) return false
 

package/src/common/serialize/bel-serializer.js

@@ -27,9 +27,9 @@ export function getAddStringContext (obfuscator, truncator) {
 
   return addString
 
-  function addString (str) {
+  function addString (str, obfuscate = true) {
     if (typeof str === 'undefined' || str === '') return ''
-    str = obfuscator?.obfuscateString(String(str)) ?? String(str)
+    str = obfuscate ? (obfuscator?.obfuscateString(String(str)) ?? String(str)) : String(str)
     str = truncator?.(str) ?? str
     if (hasOwnProp.call(stringTable, str)) {
       return numeric(stringTable[str], true)
@@ -48,7 +48,7 @@ export function addCustomAttributes (attrs, addString) {
     var type = 5
     var serializedValue
     // add key to string table first
-    key = addString(key)
+    key = addString(key, false)
 
     switch (typeof val) {
       case 'object':

package/src/common/util/console.js

@@ -7,12 +7,92 @@ import { dispatchGlobalEvent } from '../dispatch/global-event'
 
 /* eslint no-console: ["error", { allow: ["debug"] }] */
 
+/* GENERATED-WARNING-CODES:START -- run `npm run generate:warning-codes` after editing docs/warning-codes.md, do not hand-edit this block */
 /**
- * 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
+ * A helper method to warn to the console with New Relic: decoration.
+ *
+ * `code` corresponds to an entry in
+ * {@link https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md warning-codes.md}:
+ *
+ * | Code | Message |
+ * |------|---------|
+ * | 1 | An error occurred while setting a property of a Configurable |
+ * | 2 | An error occurred while setting a Configurable |
+ * | 3 | Setting a Configurable requires an object as input |
+ * | 4 | Setting a Configurable requires a model to set its initial properties |
+ * | 5 | An invalid session_replay.mask_selector was provided. \* will be used. |
+ * | 6 | An invalid session_replay.block_selector was provided and will not be used |
+ * | 7 | An invalid session_replay.mask_input_option was provided and will not be used |
+ * | 8 | Shared context requires an object as input |
+ * | 9 | An error occurred while setting SharedContext |
+ * | 10 | Failed to read from storage API |
+ * | 11 | Failed to write to the storage API |
+ * | 12 | An obfuscation replacement rule was detected missing a "regex" value. |
+ * | 13 | An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp) |
+ * | 14 | An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string) |
+ * | 15 | An error occurred while intercepting XHR |
+ * | 16 | Could not cast log message to string |
+ * | 17 | Could not calculate New Relic server time. Agent shutting down. |
+ * | 18 | RUM call failed. Agent shutting down. |
+ * | 19 | SPA scheduler is not initialized. Saved interaction is not sent! |
+ * | 20 | A problem occurred when starting up session manager. This page will not start or extend any session. |
+ * | 21 | Failed to initialize the agent. Could not determine the runtime environment. |
+ * | 22 | Failed to initialize all enabled instrument classes (agent aborted) - |
+ * | 23 | An unexpected issue occurred |
+ * | 24 | Something prevented the agent from instrumenting. |
+ * | 25 | Something prevented the agent from being downloaded. |
+ * | 26 | Failed to initialize instrument classes. |
+ * | 27 | Downloading runtime APIs failed... |
+ * | 28 | The Browser Agent is attempting to send a very large payload. This is usually tied to large amounts of custom attributes. Please check your configurations. |
+ * | 29 | Failed to wrap logger: invalid argument(s) |
+ * | 30 | Invalid log level |
+ * | 31 | Ignored log: Log is larger than maximum payload size |
+ * | 32 | Ignored log: Invalid message |
+ * | 33 | Session Replay Aborted |
+ * | 34 | Downloading and initializing a feature failed... |
+ * | 35 | Call to agent api failed. The API is not currently initialized. |
+ * | 36 | A feature is enabled but one or more dependent features have not been initialized. This may cause unintended consequences or missing data... |
+ * | 37 | Invalid feature name supplied. |
+ * | 38 | Call to api was made before agent fully initialized. |
+ * | 39 | Failed to execute setCustomAttribute. Name must be a string type. |
+ * | 40 | Failed to execute setCustomAttribute. Non-null value must be a string, number or boolean type. |
+ * | 41 | Failed to execute setUserId. Non-null value must be a string type. |
+ * | 42 | Failed to execute setApplicationVersion. Expected <String \| null> |
+ * | 43 | Agent not configured properly. |
+ * | 44 | Invalid object passed to generic event aggregate. Missing "eventType". |
+ * | 45 | An internal agent process failed to execute. |
+ * | 46 | A reserved eventType was provided to recordCustomEvent(...) -- The event was not recorded. |
+ * | 47 | We tried to access a stylesheet's contents but failed due to browser security. For best results, ensure that cross-domain CSS assets are decorated with "crossorigin='anonymous'" attribution or are otherwise publicly accessible. |
+ * | 48 | Supplied an invalid API target. Must be an <Object> that contains valid (string) id and name properties. |
+ * | 49 | Supplied API target is missing an entityGuid. Some APIs may not behave correctly without a valid entityGuid (ex. logs). |
+ * | 50 | Failed to connect. Cannot allow registered API. |
+ * | 51 | Container agent is not available to register with. Can not connect |
+ * | 52 | Unexpected problem encountered. There should be at least one app for harvest! |
+ * | 53 | Did not receive a valid entityGuid from connection response |
+ * | 54 | An experimental feature is being used. Support can not be offered for issues |
+ * | 55 | Register API has been disabled on the container agent |
+ * | 56 | Could not find a matching entity to store data |
+ * | 57 | Failed to execute measure. Arguments must have valid types. |
+ * | 58 | Failed to execute measure. Resulting duration must be non-negative. |
+ * | 59 | Session replay harvested before a session trace payload could be sent. This could be problematic for replays that rely on a trace |
+ * | 60 | Session trace aborted |
+ * | 61 | Timestamps must be non-negative and end time cannot be before start time. |
+ * | 62 | Timestamp must be a unix timestamp greater than the page origin time |
+ * | 63 | A single event was larger than the maximum allowed payload size |
+ * | 64 | Required globals have been mutated before being accessed by the browser agent. This can cause issues and should be avoided. |
+ * | 65 | Consent API argument must be boolean or undefined |
+ * | 66 | A new agent session has started |
+ * | 67 | The "spa" feature has been deprecated and disabled. Please use/import "soft_navigations" instead for tracking of BrowserInteraction data. |
+ * | 68 | API has been deregistered and can no longer be used. Call "register" API again with credentials to start over. |
+ * | 69 | More than one Browser agent is running on the page |
+ * | 70 | A session replay payload failed to send and is being retried. Recording is paused during the retry period, and will resume when a successful harvest is made. Some replay activity may be missed during retry phases. |
+ * | 71 | An invalid feature mode was detected and set to "off". |
+ *
+ * @param {number} code The warning code to emit, which will be used to link to the warning code documentation
+ * @param {*} [secondary] Secondary data to include, usually an extra message, error or object
  * @returns
  */
+/* GENERATED-WARNING-CODES:END */
 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)

package/src/common/v2/mfe-vitals.js

@@ -7,7 +7,9 @@ import { globalScope, isBrowserScope } from '../constants/runtime'
 import { now } from '../timing/now'
 
 /**
- * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
+ * @typedef {import('../../loaders/api/register-api-types').RegisterAPITimings} RegisterAPITimings
+ * @typedef {import('../../loaders/api/register-api-types').RegisterAPITarget} RegisterAPITarget
+ * @typedef {import('../../loaders/api/register-api-types').RegisterAPIVitals} RegisterAPIVitals
  */
 
 const isObservable = (node) => {
@@ -18,18 +20,34 @@ const isObservable = (node) => {
   }
 }
 
+const isMatch = (dataset, target) => dataset?.nrMfeId === target.id && (!dataset?.nrMfeObserved || dataset?.nrMfeObserved === target.instance)
+
+const escapeSelectorValue = (value) => {
+  try {
+    return globalScope.CSS.escape(value)
+  } catch (e) {
+    // give up
+    return value
+  }
+}
+
 /**
  * Check if node is within a specific MFE
  * @param {Node} node - DOM node to check
  * @param {string} id - MFE ID to match
  * @returns {boolean}
  */
-const isInMFE = (node, id) => {
-  if (!node || !id) return false
+const isInMFE = (node, target = {}) => {
+  const id = target.id
+  const instance = target.instance
+  if (!node || !id || !instance) return false
   try {
     let curr = node.nodeType === 1 ? node : node.parentElement
     while (curr?.tagName) {
-      if (curr.dataset?.nrMfeId === id) return true
+      if (isMatch(curr.dataset, target)) {
+        curr.dataset.nrMfeObserved = instance // mark that this MFE has been observed for vitals
+        return true
+      }
       curr = curr.parentNode
     }
   } catch (e) {}
@@ -42,25 +60,28 @@ const isInMFE = (node, id) => {
  * @param {Function} onMatch - Callback when matching node is *added*
  * @returns {MutationObserver}
  */
-const observeMutations = (id, onMatch) => {
+const observeMutations = (target, onMatch) => {
   // Try to find existing MFE root
-  const mfeRoot = globalScope.document?.querySelector(`[data-nr-mfe-id="${id}"]`)
+  const potentialMatches = globalScope.document?.querySelectorAll(`[data-nr-mfe-id="${escapeSelectorValue(target.id)}"]`)
+  const mfeRoot = (Array.from(potentialMatches) || []).find(x => isMatch(x.dataset, target))
   let observingRoot = !!mfeRoot
+  if (observingRoot) mfeRoot.dataset.nrMfeObserved ??= target.instance // mark that this MFE has been observed for vitals
 
   const obs = new globalScope.MutationObserver(mutations => {
     mutations.forEach(m => {
       m.addedNodes.forEach(node => {
         // Check if this is the MFE root being added
         const elem = node.nodeType === 1 ? node : null
-        if (elem?.dataset?.nrMfeId === id) {
+        if (!observingRoot && isMatch(elem?.dataset, target)) {
           // Found the root! Lets switch to observing just this subtree for performance reasons
           obs.disconnect()
           obs.observe(elem, { childList: true, subtree: true })
           observingRoot = true
+          elem.dataset.nrMfeObserved = target.instance // mark that this MFE has been observed for vitals
         }
 
         // Only check isInMFE if we're observing the whole document; skip expensive ancestor walk when observing root
-        if (isObservable(node) && (observingRoot || isInMFE(node, id))) {
+        if (isObservable(node) && (observingRoot || isInMFE(node, target))) {
           onMatch(node, obs)
         }
       })
@@ -95,15 +116,16 @@ const observePerformance = (observers, config, onEntry) => {
 
 /**
  * Tracks all Core Web Vitals for a specific MFE.
- * @param {string} id - The MFE ID to track
- * @returns {{fcp: object|null, lcp: object|null, cls: object|null, inp: object|null, disconnect: Function}}
+ * @param {RegisterAPITarget} target - The MFE target to track vitals for
+ * @param {RegisterAPITimings} timings - The timings object to use for relative time calculations
+ * @returns {RegisterAPIVitals} An object containing the vitals values and a disconnect method to stop tracking
  */
-export function trackMFEVitals (id, timings) {
-  let fcpObservedAt = null
-  let lcpObservedAt = null
+export function trackMFEVitals (target, timings) {
+  let fcpObservedAt
+  let lcpObservedAt
 
   const getTimeRelativeToScriptStart = (capturedAt) => {
-    if (capturedAt === null) return null
+    if (capturedAt == null) return capturedAt
     return capturedAt - (timings?.scriptStart || timings?.registeredAt || 0)
   }
 
@@ -115,18 +137,24 @@ export function trackMFEVitals (id, timings) {
       get value () { return getTimeRelativeToScriptStart(lcpObservedAt) }
     },
     cls: {
-      value: null
+      value: undefined
     },
     inp: {
-      value: null
+      value: undefined
     },
     disconnect: () => {}
   }
 
-  if (!id || !isBrowserScope || !globalScope.MutationObserver || !globalScope.PerformanceObserver) return vitals
+  if (!target || !isBrowserScope || !globalScope.MutationObserver || !globalScope.PerformanceObserver) return vitals
 
   const observers = []
 
+  // If FCP hasn't been observed within 10 seconds, give up and shut down all observers.
+  // Once FCP is observed, the other vitals are left to record until their natural lifespan ends.
+  setTimeout(() => {
+    if (!fcpObservedAt) vitals.disconnect()
+  }, 10000)
+
   const populateVitalMinimums = () => {
     fcpObservedAt ??= now()
     lcpObservedAt ??= now()
@@ -134,14 +162,16 @@ export function trackMFEVitals (id, timings) {
   }
 
   // if the MFE has already rendered something on the page before we could set up listeners, just populate vital minimums immediately
-  if (globalScope.document?.querySelector(`[data-nr-mfe-id="${id}"]`)) populateVitalMinimums()
+  const existingRoots = globalScope.document?.querySelectorAll(`[data-nr-mfe-id="${escapeSelectorValue(target.id)}"]`)
+  if (Array.from(existingRoots || []).some(x => isMatch(x.dataset, target))) populateVitalMinimums()
 
   // Track FCP - first contentful paint
-  observeMutations(id, (_, obs) => {
+  const fcpObs = observeMutations(target, (_, obs) => {
     // An observed "FCP" means _something_ rendered, so at minimum we can populate all the baseline values for the vitals
     populateVitalMinimums()
     obs.disconnect()
   })
+  observers.push(fcpObs)
 
   // Track LCP - largest contentful paint
   let largestSize = 0
@@ -167,7 +197,7 @@ export function trackMFEVitals (id, timings) {
     // ResizeObserver not supported
   }
 
-  const lcpObs = observeMutations(id, (node) => {
+  const lcpObs = observeMutations(target, (node) => {
     // an observed "LCP" means _something_ rendered, so at minimum we can make sure all the baseline values are populated for the vitals
     populateVitalMinimums()
 
@@ -214,7 +244,7 @@ export function trackMFEVitals (id, timings) {
   observePerformance(observers, { type: 'layout-shift', buffered: true }, (entry) => {
     if (entry.hadRecentInput) return
     ;(entry.sources || []).some(source => {
-      if (isInMFE(source.node, id)) {
+      if (isInMFE(source.node, target)) {
         // an observed "CLS" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
         populateVitalMinimums()
         vitals.cls.value += entry.value
@@ -226,8 +256,8 @@ export function trackMFEVitals (id, timings) {
 
   // Track INP - interaction to next paint
   observePerformance(observers, { type: 'event', buffered: true, durationThreshold: 40 }, (entry) => {
-    if (!entry.interactionId || !isInMFE(entry.target, id)) return
-    if (vitals.inp.value === null || entry.duration > vitals.inp.value) {
+    if (!entry.interactionId || !isInMFE(entry.target, target)) return
+    if (vitals.inp.value === undefined || entry.duration > vitals.inp.value) {
       // an observed "INP" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
       populateVitalMinimums()
       vitals.inp.value = entry.duration
@@ -252,6 +282,9 @@ export function trackMFEVitals (id, timings) {
       }
     })
     disconnectInteractionListeners()
+    ;['visibilitychange', 'pagehide'].forEach(type => {
+      globalScope.removeEventListener(type, vitals.disconnect, { once: true, passive: true })
+    })
   }
 
   // Auto-disconnect LCP observer on user interaction (per Web Vitals spec)
@@ -266,7 +299,7 @@ export function trackMFEVitals (id, timings) {
   }
 
   const handleInteraction = (event) => {
-    if (!isInMFE(event?.target, id)) return
+    if (!isInMFE(event?.target, target)) return
 
     disconnectLCP()
     disconnectInteractionListeners()

package/src/common/v2/utils.js

@@ -92,7 +92,7 @@ export function shouldDuplicate (target, aggregateInstance) {
  * @returns {Array} An array of targets found from the stack trace. If no targets are found or allowed, returns an array with undefined.
  */
 export function findTargetsFromStackTrace (agentRef) {
-  if (!agentRef?.init.api.register.enabled) return [undefined]
+  if (!agentRef?.init.api.register.enabled || !agentRef?.runtime?.registeredEntities?.length) return [undefined]
 
   const targets = []
   try {

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

@@ -6,6 +6,7 @@ import { globalScope } from '../constants/runtime'
 import { generateRandomHexString } from '../ids/unique-id'
 import { now } from '../timing/now'
 import { cleanURL } from '../url/clean-url'
+import { findTargetsFromStackTrace } from '../v2/utils'
 import { gosNREUMOriginals } from '../window/nreum'
 import { subscribeToPageUnload } from '../window/page-visibility'
 import { EVENT_TYPES } from '../constants/events'
@@ -13,7 +14,7 @@ import { EVENT_TYPES } from '../constants/events'
 const wrapped = {}
 const openWebSockets = new Set() // track all instances to close out metrics on page unload
 
-export function wrapWebSocket (sharedEE) {
+export function wrapWebSocket (sharedEE, agentRef) {
   const originals = gosNREUMOriginals().o
   if (!originals.WS) return sharedEE
 
@@ -33,7 +34,7 @@ export function wrapWebSocket (sharedEE) {
         ws.nrData.connectedDuration = unloadTime - ws.nrData.openedAt
       }
 
-      wsEE.emit('ws', [ws.nrData], ws)
+      wsEE.emit('ws', [ws.nrData, ws.targets], ws)
     })
   })
 
@@ -61,6 +62,7 @@ export function wrapWebSocket (sharedEE) {
       super(...args)
       /** @type {WebSocketData} */
       this.nrData = new WebSocketData(args[0], args[1])
+      this.targets = findTargetsFromStackTrace(agentRef)
 
       this.addEventListener('open', () => {
         this.nrData.openedAt = now()
@@ -90,7 +92,7 @@ export function wrapWebSocket (sharedEE) {
         this.nrData.connectedDuration = this.nrData.closedAt - this.nrData.openedAt
 
         openWebSockets.delete(this) // remove from tracking set since it's now closed
-        wsEE.emit('ws', [this.nrData], this)
+        wsEE.emit('ws', [this.nrData, this.targets], this)
       })
     }
 

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

@@ -102,22 +102,28 @@ export class Aggregate extends AggregateBase {
       [AJAX_ID]: generateUuid() // all AjaxRequest events should have a unique identifier to allow for easier grouping and analysis in the UI
     }
 
-    event.gql = params.gql = parseGQL({
+    event.gql = parseGQL({
       body: ctx.requestBody,
       query: ctx.parsedOrigin?.search
     })
-    if (event.gql) event.gql.operationHasErrors = params.gql.operationHasErrors = hasGQLErrors(ctx.responseBody)
+    if (event.gql) event.gql.operationHasErrors = hasGQLErrors(ctx.responseBody)
 
     const capturePayloadSetting = this.agentRef.init.ajax.capture_payloads
-    const shouldCapturePayload = canCapturePayload(capturePayloadSetting, params.status, event.gql?.operationHasErrors)
+    const shouldCapturePayload = canCapturePayload(capturePayloadSetting, {
+      statusCode: event.status,
+      hasGQLErrors: event.gql?.operationHasErrors,
+      payloadHostname: params.hostname,
+      payloadHost: params.host,
+      payloadPathname: params.pathname
+    }, this.agentRef.beacons)
 
     if (shouldCapturePayload) {
       // Store raw data; obfuscation and truncation will happen in the serializer
-      params.requestQuery = event.requestQuery = parseQueryString(ctx.parsedOrigin?.search)
-      params.requestHeaders = event.requestHeaders = ctx.requestHeaders
-      params.responseHeaders = event.responseHeaders = ctx.responseHeaders
-      if (isLikelyHumanReadable(ctx.requestHeaders, ctx.requestBody)) params.requestBody = event.requestBody = ctx.requestBody
-      if (isLikelyHumanReadable(ctx.responseHeaders, ctx.responseBody)) params.responseBody = event.responseBody = ctx.responseBody
+      event.requestQuery = parseQueryString(ctx.parsedOrigin?.search)
+      event.requestHeaders = ctx.requestHeaders
+      event.responseHeaders = ctx.responseHeaders
+      if (isLikelyHumanReadable(ctx.requestHeaders, ctx.requestBody)) event.requestBody = ctx.requestBody
+      if (isLikelyHumanReadable(ctx.responseHeaders, ctx.responseBody)) event.responseBody = ctx.responseBody
     }
 
     if (ctx.dt) {

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

@@ -252,20 +252,22 @@ export class Aggregate extends AggregateBase {
       }, this.featureName, this.ee)
 
       if (agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled) {
-        registerHandler('ws-complete', (nrData) => {
-          const event = {
-            ...nrData,
-            eventType: EVENT_TYPES.WS,
-            timestamp: this.#toEpoch(nrData.timestamp),
-            openedAt: this.#toEpoch(nrData.openedAt),
-            closedAt: this.#toEpoch(nrData.closedAt)
-          }
+        registerHandler('ws-complete', (nrData, targets = [undefined]) => {
+          targets.forEach(target => {
+            const event = {
+              ...nrData,
+              eventType: EVENT_TYPES.WS,
+              timestamp: this.#toEpoch(nrData.timestamp),
+              openedAt: this.#toEpoch(nrData.openedAt),
+              closedAt: this.#toEpoch(nrData.closedAt)
+            }
 
-          // Report supportability metrics for WebSocket completion
-          this.reportSupportabilityMetric('WebSocket/Completed/Seen')
-          this.reportSupportabilityMetric('WebSocket/Completed/Bytes', stringify(event).length)
+            // Report supportability metrics for WebSocket completion
+            this.reportSupportabilityMetric('WebSocket/Completed/Seen')
+            this.reportSupportabilityMetric('WebSocket/Completed/Bytes', stringify(event).length)
 
-          this.addEvent(event)
+            this.addEvent(event, target)
+          })
         }, this.featureName, this.ee)
       }
       if (!agentRef.init.feature_flags.includes('no_spv')) {

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

@@ -55,9 +55,9 @@ export class Instrument extends InstrumentBase {
 
     let historyEE
     if (websocketsEnabled) { // this can apply outside browser scope such as in worker
-      const websocketsEE = wrapWebSocket(this.ee)
-      websocketsEE.on('ws', (nrData) => {
-        handle('ws-complete', [nrData], undefined, this.featureName, this.ee)
+      const websocketsEE = wrapWebSocket(this.ee, agentRef)
+      websocketsEE.on('ws', (nrData, targets) => {
+        handle('ws-complete', [nrData, targets], undefined, this.featureName, this.ee)
       })
     }
     if (securityPolicyViolationEnabled) {

package/src/loaders/api/register-api-types.js

@@ -53,4 +53,12 @@
  * @property {string} type - The type of timing associated with the registered entity, 'script' or 'link' if found with the performance resource API, 'fetch' for dynamic imports, 'inline' if found to be associated with the root document URL, or 'unknown' if no associated resource could be found.
  */
 
+/**
+ * @typedef {Object} RegisterAPIVitals
+ * @property {number} [fcp] - The first contentful paint timing for the registered entity.
+ * @property {number} [lcp] - The largest contentful paint timing for the registered entity.
+ * @property {number} [cls] - The cumulative layout shift score for the registered entity.
+ * @property {number} [inp] - The interaction to next paint timing for the registered entity.
+ */
+
 export default {}

package/src/loaders/api/register.js

@@ -85,7 +85,7 @@ function register (agentRef, target) {
   const timings = findScriptTimings()
 
   // Track MFE vitals for this entity
-  const vitals = trackMFEVitals(target.id, timings)
+  const vitals = trackMFEVitals(target, timings)
 
   const attrs = {}
 
@@ -203,10 +203,10 @@ function register (agentRef, target) {
       timeToLoad: timeToFetch + timeToExecute, // fetch time and script time together
       timeToRegister: timings.registeredAt, // timestamp when register() was called
       // leave room to extend these with more data keys as needed
-      'nr.vitals.fcp.value': vitals.fcp?.value ?? null, // FCP vital object with value and metadata
-      'nr.vitals.lcp.value': vitals.lcp?.value ?? null, // LCP vital object with value and metadata
-      'nr.vitals.cls.value': vitals.cls?.value ?? null, // CLS vital object with value and metadata
-      'nr.vitals.inp.value': vitals.inp?.value ?? null // INP vital object with value and metadata
+      ...(vitals.fcp.value >= 0 && { 'nr.vitals.fcp.value': vitals.fcp.value }), // FCP vital object with value and metadata
+      ...(vitals.lcp.value >= 0 && { 'nr.vitals.lcp.value': vitals.lcp.value }), // LCP vital object with value and metadata
+      ...(vitals.cls.value >= 0 && { 'nr.vitals.cls.value': vitals.cls.value }), // CLS vital object with value and metadata
+      ...(vitals.inp.value >= 0 && { 'nr.vitals.inp.value': vitals.inp.value }) // INP vital object with value and metadata
     }
 
     api.recordCustomEvent('MicroFrontEndTiming', eventData)