@newrelic/browser-agent 1.319.0 → 1.320.0

package/src/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,73 @@ 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 = `${asset}::${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
 }
 
 /**
@@ -92,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 {
@@ -104,8 +168,30 @@ 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
 }
 
 /**
@@ -118,3 +204,13 @@ 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/src/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
@@ -481,19 +482,6 @@ function subscribeToEvents (agentRef, ee, handler, dt) {
   }
 }
 
-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/src/features/utils/instrument-base.js

@@ -115,6 +115,18 @@ export class InstrumentBase extends FeatureBase {
         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
        * it's only responsible for aborting its one specific feature, rather than all.

package/src/interfaces/registered-iframe-entity.js

@@ -0,0 +1,482 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// libraries
+import { onCLS, onFCP, onINP, onLCP } from 'web-vitals'
+// internal
+import { globalScope, isBrowserScope } from '../common/constants/runtime'
+import { isIFrameWindow } from '../common/dom/iframe'
+import { now } from '../common/timing/now'
+import { warn } from '../common/util/console'
+import { findScriptTimings } from '../common/v2/script-tracker'
+import { addUrl } from '../common/url/add-url'
+import { generateUuid } from '../common/ids/unique-id'
+import { IFRAME_TIMING_UPDATE, IFRAME_API, IFRAME_API_RESPONSE, IFRAME_VITALS_UPDATE, IFRAME_AJAX } from '../common/constants/iframe-constants'
+import { castErrorEvent, castError, castPromiseRejectionEvent } from '../features/jserrors/shared/cast-error'
+
+const REGISTER = 'register' // define it here to prevent importing the full list of constants for build size.
+const VITALS = [[onCLS, 'cls'], [onLCP, 'lcp'], [onFCP, 'fcp'], [onINP, 'inp']]
+const AJAX_INITIATOR_TYPES = { xmlhttprequest: 'xhr', fetch: 'fetch', beacon: 'beacon' }
+
+/**
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPI} RegisterAPI
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPIMetadata} RegisterAPIMetadata
+ * @typedef {import('../loaders/api/register-api-types').RegisterAPIConstructor} RegisterAPIConstructor
+ */
+
+/**
+ * @experimental
+ * IMPORTANT: This feature is being developed for use internally and is not in a public-facing production-ready state.
+ * It is not recommended for use in production environments and will not receive support for issues.
+ *
+ * An interface for registering an external caller to report through the base agent to a different target than the base agent.
+ */
+export class RegisteredIframeEntity {
+  /** @type {RegisterAPIMetadata} */
+  metadata = {
+    target: {},
+    timings: {},
+    customAttributes: {},
+    vitals: {
+      cls: { value: null },
+      lcp: { value: null },
+      fcp: { value: null },
+      inp: { value: null }
+    }
+  }
+
+  /** @private Map to store pending promise resolvers keyed by message ID */
+  #pendingMessages = new Map()
+  /** @private Unique ID for this iframe interface instance to correlate messages */
+  #iframeInterfaceId = generateUuid()
+  /** @private Counter for generating unique message IDs */
+  #messageIdCounter = 0
+  /** @private Promise that resolves when registration with parent completes */
+  #registrationPromise = null
+  /** @private Resource timing observer used to seed AJAX state */
+  #resourceObserver = null
+  /** @private Original target descriptor (serializable) for postMessage */
+  #targetDescriptor = null
+  /**
+   * Whether this entity is blocked from sending further calls to the container. Backed by
+   * `this.metadata.target.blocked` (rather than an independent field) so that this always
+   * reflects the container's blocked state too, including future syncs from response metadata --
+   * there is only ever one source of truth for "blocked", not one flag per side.
+   * @returns {boolean}
+   */
+  get blocked () {
+    return !!this.metadata.target.blocked
+  }
+
+  set blocked (value) {
+    this.metadata.target.blocked = value
+  }
+
+  /** @private Parent window origin for secure postMessage */
+  #parentOrigin = (() => {
+    try {
+      return globalScope?.location?.ancestorOrigins?.[0] || (globalScope?.document?.referrer ? new URL(globalScope.document.referrer).origin : '*')
+    } catch (e) {
+      return '*'
+    }
+  })()
+
+  /**
+   *
+   * @param {RegisterAPIConstructor} opts The options for setting up the registered iframe entity.
+   */
+  constructor (opts) {
+    warn(54)
+    // Store original descriptor for postMessage (before any function merging)
+    this.metadata.target = this.#targetDescriptor = opts
+
+    if (!isBrowserScope || !isIFrameWindow(globalScope)) {
+      warn(72)
+      this.blocked = true
+      return
+    }
+
+    if (this.#parentOrigin === '*') {
+      // If the parent's origin cannot be determined, fail closed rather than allow postMessage
+      // traffic to/from any origin
+      warn(78)
+      this.blocked = true
+      return
+    }
+
+    // Store the registration promise so other methods can wait for it
+    this.#registrationPromise = this.#register(opts)
+    this.#registrationPromise
+      .then(() => {
+        const timings = findScriptTimings()
+        // Send initial timing values, skipping ones still at their "not yet known" default
+        // (e.g. reportedAt: undefined, fetchStart: 0) to avoid pointless postMessage calls
+        for (const [key, value] of Object.entries(timings)) {
+          if (key !== 'correlation' && value) {
+            this.#postTimingToAgent(key, value)
+          }
+        }
+        // Proxy the timings object to watch for updates to fetchStart, fetchEnd, asset, type
+        this.metadata.timings = new Proxy(timings, {
+          set: (target, key, value) => {
+            const changed = target[key] !== value
+            target[key] = value
+
+            // Send updates for these 4 properties when they change
+            if (changed && this.metadata.target.id && key !== 'correlation') {
+              this.#postTimingToAgent(key, value)
+            }
+            return true
+          }
+        })
+      })
+      .catch(() => {})
+
+    this.#setupErrorListeners()
+    this.#setupVitalsListeners()
+    this.#setupAjaxObserver()
+    this.#setupResponseListener()
+    this.#bindPublicMethods()
+  }
+
+  /**
+   * Registers this entity with the parent agent, then seeds initial timings and FCP.
+   * @private
+   * @param {RegisterAPIConstructor} opts
+   * @returns {Promise<void>}
+   */
+  async #register (opts) {
+    try {
+      const response = await this.#postMethodToAgent(REGISTER, [opts])
+      if (response.metadata) Object.assign(this.metadata, response.metadata)
+      return response
+    } catch (err) {
+      warn(73, err)
+      this.blocked = true
+      throw err
+    }
+  }
+
+  /**
+   * Wires up global error/rejection listeners that funnel into noticeError.
+   * @private
+   */
+  #setupErrorListeners () {
+    globalScope.addEventListener('error', err => {
+      this.noticeError(castErrorEvent(err))
+    })
+
+    globalScope.addEventListener('unhandledrejection', event => {
+      this.noticeError(castPromiseRejectionEvent(event))
+    })
+  }
+
+  /**
+   * Wires up web-vitals callbacks to report vitals updates to the parent.
+   * @private
+   */
+  #setupVitalsListeners () {
+    VITALS.forEach(([vitalFn, property]) => {
+      vitalFn(({ value }) => {
+        this.metadata.vitals[property].value = value
+        this.#postMessageToParent(IFRAME_VITALS_UPDATE, {
+          entries: [{ property, value }]
+        })
+      }, { reportAllChanges: property === 'cls' || property === 'inp' })
+    })
+  }
+
+  /**
+   * Instruments ajax using buffered resource timing so pre-registration entries are included.
+   * @private
+   */
+  #setupAjaxObserver () {
+    if (!globalScope.PerformanceObserver?.supportedEntryTypes?.includes('resource')) return
+
+    this.#resourceObserver = new globalScope.PerformanceObserver(list => {
+      // Batched into a single postMessage per observer callback rather than one per entry --
+      // with buffered: true this callback can fire with dozens of pre-existing entries at once,
+      // and each postMessage carries its own await/registration/dispatch overhead independent of
+      // payload size, so sending them individually multiplies that overhead for no benefit.
+      const entries = list.getEntries().map(resource => this.#buildAjaxPayload(resource)).filter(Boolean)
+      if (!entries.length) return
+      this.#postMessageToParent(IFRAME_AJAX, { entries })
+    })
+    this.#resourceObserver.observe({ type: 'resource', buffered: true })
+  }
+
+  /**
+   * Builds the AJAX event payload for a single resource timing entry, if it looks like a network request.
+   * @private
+   * @param {PerformanceResourceTiming} resource
+   * @returns {object|undefined}
+   */
+  #buildAjaxPayload (resource) {
+    if (!(resource.initiatorType in AJAX_INITIATOR_TYPES)) return
+    // Cross-origin requests without a Timing-Allow-Origin response header report responseStatus (and
+    // transferSize) as 0 per spec -- that's a browser privacy restriction, not evidence the request
+    // failed, so it should still be reported rather than dropped. status: 0 is already the established
+    // "unknown" convention elsewhere in the ajax feature (see features/ajax/instrument/index.js).
+    const params = { status: resource.responseStatus }
+    const metrics = { rxSize: resource.transferSize, duration: Math.floor(resource.duration), cbTime: 0 }
+    addUrl(params, resource.name)
+
+    return {
+      params,
+      metrics,
+      start: resource.startTime,
+      end: resource.responseEnd,
+      initiatorType: AJAX_INITIATOR_TYPES[resource.initiatorType]
+    }
+  }
+
+  /**
+   * Listens for postMessage responses from the parent window and routes them to pending resolvers.
+   * @private
+   */
+  #setupResponseListener () {
+    globalScope.addEventListener('message', (event) => {
+      if (this.blocked) return
+      // Validate message structure
+      if (event.data?.type !== IFRAME_API_RESPONSE) return
+
+      // Validate iframeInterfaceId first to confirm this message actually claims to be addressed
+      // to this instance -- messageIds are only unique per-instance, so we must not act on one
+      // (including rejecting) until we know it's actually meant for us.
+      if (event.data.iframeInterfaceId !== this.#iframeInterfaceId) {
+        warn(75)
+        return
+      }
+
+      // Validate origin now that we know the message claims to be for us. Reject the pending
+      // call immediately rather than leaving it to time out, since we know exactly which
+      // messageId this response was for.
+      if (event.origin !== this.#parentOrigin) {
+        warn(74, event.origin)
+        this.#closePending({ messageId: event.data.messageId, error: 'Rejected message from unauthorized origin' })
+        return
+      }
+
+      this.#closePending(event.data)
+    })
+  }
+
+  /**
+   * Explicitly binds API methods as own properties for better console visibility.
+   * @private
+   */
+  #bindPublicMethods () {
+    this.addPageAction = this.addPageAction.bind(this)
+    this.deregister = this.deregister.bind(this)
+    this.recordCustomEvent = this.recordCustomEvent.bind(this)
+    this.measure = this.measure.bind(this)
+    this.setCustomAttribute = this.setCustomAttribute.bind(this)
+    this.noticeError = this.noticeError.bind(this)
+    this.setUserId = this.setUserId.bind(this)
+    this.setApplicationVersion = this.setApplicationVersion.bind(this)
+    this.log = this.log.bind(this)
+  }
+
+  /**
+   * Low-level helper to send postMessage to parent window with error handling
+   * @private
+   * @param {string} type - The message type to send
+   * @param {object} data - The message payload to send
+   * @param {boolean} [bypassRegistration=false] - Whether to bypass waiting for registration
+   * @param {boolean} [needsResponse=false] - Whether to wait for a response from the parent
+   * @returns {Promise<void>}
+   */
+  async #postMessageToParent (type, data, bypassRegistration = false, needsResponse = false) {
+    if (this.blocked) return
+
+    const timestamp = now()
+    try {
+      await (bypassRegistration ? Promise.resolve() : this.#registrationPromise)
+      const messageId = ++this.#messageIdCounter
+      const pending = needsResponse ? this.#openPending(messageId) : Promise.resolve()
+      globalScope.parent.postMessage({
+        type,
+        target: this.#targetDescriptor,
+        timestamp,
+        iframeInterfaceId: this.#iframeInterfaceId,
+        messageId,
+        ...data
+      }, this.#parentOrigin)
+      return await pending
+    } catch (err) {
+      // If the postMessage never responded with a new message, it will surface here -- but, this could be expected, as many messages are sent to the parent that don't require a response.
+    }
+  }
+
+  /**
+   * Sends a timing property update message to the parent window
+   * @private
+   * @param {string} property - The property name that changed
+   * @param {*} value - The new value
+   */
+  #postTimingToAgent (property, value) {
+    this.#postMessageToParent(IFRAME_TIMING_UPDATE, {
+      entries: [{ property, value }]
+    })
+  }
+
+  /**
+   * Sends a message to the parent window's agent using postMessage API
+   * @private
+   * @param {string} method The API method name to invoke
+   * @param {Array} args The arguments to pass to the method
+   * @returns {Promise<any>} Promise that resolves with the response from the agent
+   */
+  async #postMethodToAgent (method, args) {
+    return await this.#postMessageToParent(IFRAME_API, {
+      entries: [{ method, args }]
+    }, method === REGISTER, true)
+  }
+
+  /**
+   * Opens a pending entry for a message awaiting a response, auto-rejecting after a timeout.
+   * @private
+   * @param {number} messageId
+   * @returns {Promise<any>}
+   */
+  #openPending (messageId) {
+    const resolvers = {}
+    const pending = new Promise((resolve, reject) => {
+      resolvers.resolve = resolve
+      resolvers.reject = reject
+    })
+    this.#pendingMessages.set(messageId, resolvers)
+    // Timeout after 10 seconds
+    setTimeout(() => this.#closePending({ messageId, error: 'Timed out' }), 10000)
+    return pending
+  }
+
+  /**
+   * Resolves or rejects a pending message by ID, based on an incoming response (or timeout).
+   * @private
+   * @param {{messageId: number, error?: string, result?: any, metadata?: object}} event
+   */
+  #closePending (event = {}) {
+    const { messageId, error, result, metadata } = event
+    const pending = this.#pendingMessages.get(messageId)
+    if (pending) {
+      if (error) pending.reject(new Error(error))
+      else pending.resolve({ result, metadata })
+      this.#pendingMessages.delete(messageId)
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Reports a browser PageAction event along with a name and optional attributes to the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addpageaction/}
+   * @param {string} name Name or category of the action. Reported as the actionName attribute.
+   * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}. The key is reported as its own PageAction attribute with the specified values.
+   */
+  addPageAction (name, attributes) {
+    this.#postMethodToAgent('addPageAction', [name, attributes])
+  }
+
+  /**
+   * @experimental
+   * IMPORTANT: This feature is being developed for use internally and is not in a public-facing production-ready state.
+   * It is not recommended for use in production environments and will not receive support for issues.
+   *
+   * Deregister the registered entity (this), which blocks its use and captures end of life timings.
+   * @returns {Promise<void>}
+   */
+  async deregister () {
+    try {
+      this.#resourceObserver?.disconnect()
+    } catch (err) { }
+
+    this.#resourceObserver = null
+    try {
+      const response = await this.#postMethodToAgent('deregister', [])
+      if (response?.metadata) Object.assign(this.metadata, response.metadata)
+    } finally {
+      // Always end up blocked locally, even if the round trip to the container never resolved --
+      // deregistering is a one-way decision and further local calls should stop regardless.
+      this.blocked = true
+    }
+  }
+
+  /**
+     * Records a custom event with a specified eventType and attributes.
+     * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordCustomEvent/}
+     * @param {string} eventType The eventType to store the event as.
+     * @param {Object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}.
+     */
+  recordCustomEvent (eventType, attributes) {
+    this.#postMethodToAgent('recordCustomEvent', [eventType, attributes])
+  }
+
+  /**
+   * 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 {{start?: number|PerformanceMark, end?: number|PerformanceMark, customAttributes?: object}} [options] An object used to control the way the measure API operates
+   * @returns {Promise<{start: number, end: number, duration: number, customAttributes: object}>} Measurement details
+   */
+  async measure (name, options) {
+    return (await this.#postMethodToAgent('measure', [name, options])).result
+  }
+
+  /**
+   * Adds a user-defined attribute name and value to subsequent events on the page for the registered target. Note -- the persist flag does not work with the register API.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setcustomattribute/}
+   * @param {string} name Name of the attribute. Appears as column in the PageView event. It will also appear as a column in the PageAction event if you are using it.
+   * @param {string|number|boolean|null} value Value of the attribute. Appears as the value in the named attribute column in the PageView event. It will appear as a column in the PageAction event if you are using it. Custom attribute values cannot be complex objects, only simple types such as Strings, Integers and Booleans. Passing a null value unsets any existing attribute of the same name.
+   * @param {boolean} [persist] Default false. If set to true, the name-value pair will also be set into the browser's storage API. Then on the following instrumented pages that load within the same session, the pair will be re-applied as a custom attribute.
+   */
+  setCustomAttribute (name, value, persist) {
+    this.#postMethodToAgent('setCustomAttribute', [name, value, persist])
+  }
+
+  /**
+   * Identifies a browser error without disrupting your app's operations for the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/noticeerror/}
+   * @param {Error|string} error Provide a meaningful error message that you can use when analyzing data on browser's JavaScript errors page.
+   * @param {object} [customAttributes] An object containing name/value pairs representing custom attributes.
+   */
+  noticeError (error, customAttributes) {
+    this.#postMethodToAgent('noticeError', [castError(error), customAttributes])
+  }
+
+  /**
+   * Adds a user-defined identifier string to subsequent events on the page for the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setuserid/}
+   * @param {string|null} value A string identifier for the end-user, useful for tying all browser events to specific users. The value parameter does not have to be unique. If IDs should be unique, the caller is responsible for that validation. Passing a null value unsets any existing user ID.
+   * @param {boolean} [resetSession=false] Optional param. Should not be used from a registered entity context. To reset a session when updating user id, must be initiated by the main agent.
+   */
+  setUserId (value, resetSession = false) {
+    this.#postMethodToAgent('setUserId', [value, resetSession])
+  }
+
+  /**
+   * Adds a user-defined application version string to subsequent events on the page for the registered target.
+   * This decorates all payloads with an attribute of `application.version` which is queryable in NR1.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setapplicationversion/}
+   * @param {string|null} value A string identifier for the application version, useful for
+   * tying all browser events to a specific release tag. The value parameter does not
+   * have to be unique. Passing a null value unsets any existing value.
+   */
+  setApplicationVersion (value) {
+    this.#postMethodToAgent('setApplicationVersion', [value])
+  }
+
+  /**
+   * Capture a single log for the registered target.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/log/}
+   * @param {string} message String to be captured as log message
+   * @param {{customAttributes?: object, level?: 'ERROR'|'TRACE'|'DEBUG'|'INFO'|'WARN'}} [options] customAttributes defaults to `{}` if not assigned, level defaults to `info` if not assigned.
+  */
+  log (message, options) {
+    this.#postMethodToAgent('log', [message, options])
+  }
+}