@newrelic/browser-agent 1.319.0 → 1.320.0

package/dist/esm/common/v2/timing-factory.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function timingFactory(getLazyValue = () => {}, override) {
+  return {
+    get: () => override !== undefined ? override : getLazyValue(),
+    set: newValue => {
+      override = newValue;
+    }
+  };
+}

package/dist/esm/common/v2/utils.js

@@ -16,6 +16,18 @@ export const V2_TYPES = {
   BA: 'BA'
 };
 
+/**
+ * Returns a single registered entity associated with a given iframe interface ID. Returns undefined if no entity is found.
+ * @param {string} iframeInterfaceId
+ * @param {*} agentRef the agent reference
+ * @returns {import("../../loaders/api/register-api-types").RegisterAPI|undefined}
+ */
+export function getRegisteredEntityByIframeInterfaceId(iframeInterfaceId, agentRef) {
+  if (!isValid(iframeInterfaceId, agentRef)) return undefined;
+  const registeredEntities = agentRef.runtime.registeredEntities;
+  return registeredEntities?.find(entity => entity.metadata.target.iframeInterfaceId === iframeInterfaceId);
+}
+
 /**
  * Returns the registered target associated with a given ID. Returns an empty array if no target is found.
  * @param {string|number} id
@@ -23,21 +35,69 @@ export const V2_TYPES = {
  * @returns {import("../../interfaces/registered-entity").RegisterAPIMetadataTarget[]}
  */
 export function getRegisteredTargetsFromId(id, agentRef) {
-  if (!id || !agentRef?.init.api.register.enabled) return [];
+  if (!isValid(id, agentRef)) return [];
   const registeredEntities = agentRef.runtime.registeredEntities;
   return registeredEntities?.filter(entity => String(entity.metadata.target.id) === String(id)).map(entity => entity.metadata.target) || [];
 }
 
 /**
  * Returns the registered target(s) associated with a given filename if found in the resource timing API during registration. Returns an empty array if no target is found.
+ * Multiple registrations that resolve to the same underlying script asset AND represent the same logical MFE (i.e.
+ * share the same customer-supplied `target.id`) are collapsed to a single target via
+ * {@link dedupeRegisteredEntitiesByAsset}, since auto-instrumented events (AJAX, JS errors, logs, WebSockets) should
+ * only be reported once per real occurrence when the same MFE was registered many times over -- not once per
+ * duplicate registration. Distinct MFEs (different `target.id`) that happen to share a script (e.g. two different
+ * MFEs both registered from the same inline `<script>` block) are intentionally NOT collapsed, since each is a
+ * genuinely different entity that should still receive its own copy of the matched event.
  * @param {string} filename
  * @param {*} agentRef
  * @returns {import("../../interfaces/registered-entity").RegisterAPIMetadataTarget[]}
  */
 export function getRegisteredTargetsFromFilename(filename, agentRef) {
-  if (!filename || !agentRef?.init.api.register.enabled) return [];
+  if (!isValid(filename, agentRef)) return [];
   const registeredEntities = agentRef.runtime.registeredEntities;
-  return registeredEntities?.filter(entity => entity.metadata.timings?.asset?.endsWith(filename)).map(entity => entity.metadata.target) || [];
+  const matches = registeredEntities?.filter(entity => entity.metadata.timings?.asset?.endsWith(filename));
+  return dedupeRegisteredEntitiesByAsset(matches).map(entity => entity.metadata.target);
+}
+
+/**
+ * Collapses a list of registered entities down to one canonical entity per unique, defined `metadata.timings.asset` +
+ * `target.id` combination. Entities whose asset could not be resolved (undefined -- e.g. inline scripts or scripts
+ * not found in the resource timing buffer) are never deduped against each other or against resolved entities, since
+ * there is no signal that they represent the same underlying script. Entities that share an asset but have different
+ * `target.id`s are never deduped against each other either, since a differing id means the customer registered
+ * genuinely distinct MFEs (not duplicate registrations of the same one).
+ *
+ * Canonical selection per asset+id: prefer an entity whose target has not been deregistered (`target.blocked ===
+ * false`) over one that has; otherwise the first-encountered entity wins, for determinism.
+ * @param {Array} entities registered entities (each with `metadata.timings.asset` and `metadata.target`)
+ * @returns {Array} deduped list of entities, preserving relative order of first occurrence
+ */
+export function dedupeRegisteredEntitiesByAsset(entities) {
+  if (!entities?.length) return entities || [];
+  const byKey = new Map(); // `${asset}::${id}` -> canonical entity
+  const result = [];
+  for (const entity of entities) {
+    const asset = entity.metadata?.timings?.asset;
+    if (!asset) {
+      // can't safely dedupe unresolved-asset entities -- always keep as-is
+      result.push(entity);
+      continue;
+    }
+    const key = "".concat(asset, "::").concat(entity.metadata?.target?.id);
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, entity);
+      result.push(entity);
+    } else if (existing.metadata.target?.blocked && !entity.metadata.target?.blocked) {
+      // swap in a non-deregistered target as the canonical one for this asset+id
+      const idx = result.indexOf(existing);
+      if (idx !== -1) result[idx] = entity;
+      byKey.set(key, entity);
+    }
+    // else: existing canonical entity wins (already non-blocked, or both blocked -- first wins); drop this duplicate
+  }
+  return result;
 }
 
 /**
@@ -96,7 +156,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 || !agentRef?.runtime?.registeredEntities?.length) return [undefined];
+  if (!isValid(true, agentRef) || !agentRef?.runtime?.registeredEntities?.length) return [undefined];
   const targets = [];
   try {
     var urls = extractUrlsFromStack(getDeepStackTrace());
@@ -107,8 +167,29 @@ export function findTargetsFromStackTrace(agentRef) {
   } catch (err) {
     // Silent catch to prevent errors from propagating
   }
-  if (!targets.length) targets.push(undefined); // if we can't find any targets from the stack trace, return an array with undefined to signify the container agent is the target
-  return targets;
+  const deduped = dedupeTargetsByInstance(targets);
+  if (!deduped.length) deduped.push(undefined); // if we can't find any targets from the stack trace, return an array with undefined to signify the container agent is the target
+  return deduped;
+}
+
+/**
+ * Removes duplicate targets from an array, keyed by `target.instance`. This guards against the same canonical
+ * target re-entering the array via multiple matched stack-frame URLs (e.g. a recursive call whose stack contains the
+ * same file at multiple depths). Entries with no `instance` (i.e. `undefined`, meaning "the container agent")
+ * naturally collapse to a single entry too, which is the desired behavior.
+ * @param {Array} targets
+ * @returns {Array} deduped list of targets, preserving relative order of first occurrence
+ */
+export function dedupeTargetsByInstance(targets) {
+  const seen = new Set();
+  const result = [];
+  for (const target of targets) {
+    const key = target?.instance;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(target);
+  }
+  return result;
 }
 
 /**
@@ -120,4 +201,14 @@ export function findTargetsFromStackTrace(agentRef) {
  */
 function supportsV2(aggregateInstance) {
   return aggregateInstance?.harvestEndpointVersion === 2;
+}
+
+/**
+ * Determines if the given identifier and agent reference are valid for use for entity lookups and other operations in the utils methods. This is a common check that is used across multiple methods in this module to ensure that the necessary data is present and that the register API is enabled before attempting to perform operations that depend on those things.
+ * @param {*} identifier The identifier to check.
+ * @param {*} agentRef The agent reference to check.
+ * @returns {boolean} Returns true if the identifier and agent reference are valid, false otherwise.
+ */
+function isValid(identifier, agentRef) {
+  return !!identifier && !!agentRef?.init.api.register.enabled;
 }

package/dist/esm/features/ajax/instrument/index.js

@@ -20,6 +20,7 @@ import { SUPPORTABILITY_METRIC } from '../../metrics/constants';
 import { now } from '../../../common/timing/now';
 import { hasUndefinedHostname } from '../../../common/deny-list/deny-list';
 import { extractUrl } from '../../../common/url/extract-url';
+import { addUrl } from '../../../common/url/add-url';
 var handlers = ['load', 'error', 'abort', 'timeout'];
 var handlersLen = handlers.length;
 var origRequest = gosNREUMOriginals().o.REQ;
@@ -434,17 +435,6 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     ctx.loadCaptureCalled = true;
   }
 }
-function addUrl(ctx, url) {
-  var parsed = parseUrl(url);
-  var params = ctx.params || ctx;
-  params.hostname = parsed.hostname;
-  params.port = parsed.port;
-  params.protocol = parsed.protocol;
-  params.host = parsed.hostname + ':' + parsed.port;
-  params.pathname = parsed.pathname;
-  ctx.parsedOrigin = parsed;
-  ctx.sameOrigin = parsed.sameOrigin;
-}
 function parseResponseHeaders(headerStr) {
   const headers = {};
   if (!headerStr) return headers;

package/dist/esm/features/utils/instrument-base.js

@@ -113,6 +113,19 @@ export class InstrumentBase extends FeatureBase {
         this.ee.emit('internal-error', [e]);
         handle(SESSION_ERROR, [e], undefined, this.featureName, this.ee);
       }
+      if (agentRef.init.api.register.allow_iframe_bridge) {
+        try {
+          // This chunk doesn't exist in the lite build (see webpack IgnorePlugin config) since none
+          // of lite's features wire up agent.register -- guard against that rather than letting an
+          // unhandled rejection surface if this flag is ever set on a lite page.
+          const {
+            setupIframeMFEMessageListener
+          } = await import(/* webpackChunkName: "iframe-message-handler" */'../../loaders/configure/iframe-message-handler');
+          setupIframeMFEMessageListener(agentRef);
+        } catch (e) {
+          warn(23, e);
+        }
+      }
 
       /**
        * Note this try-catch differs from the one in Agent.run() in that it's placed later in a page's lifecycle and