@newrelic/browser-agent 1.236.0 → 1.237.1

package/dist/esm/features/session_replay/aggregate/index.js

@@ -19,6 +19,7 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { SESSION_EVENTS, MODE } from '../../../common/session/session-entity';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
+import { obj as encodeObj } from '../../../common/url/encode';
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8';
@@ -29,8 +30,12 @@ let recorder, gzipper, u8;
 export const MAX_PAYLOAD_SIZE = 1000000;
 /** Unloading caps around 64kb */
 export const IDEAL_PAYLOAD_SIZE = 64000;
-/** Interval between forcing new full snapshots in "error" mode */
-const CHECKOUT_MS = 30000;
+/** Interval between forcing new full snapshots -- 30 seconds in error mode, 5 minutes in full mode */
+const CHECKOUT_MS = {
+  [MODE.ERROR]: 30000,
+  [MODE.FULL]: 300000,
+  [MODE.OFF]: 0
+};
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -62,6 +67,12 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate that the payload being sent contains an error.  Used for query/filter purposes in UI */
     this.hasError = false;
 
+    /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs. */
+    this.timestamp = {
+      first: undefined,
+      last: undefined
+    };
+
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0;
     const shouldSetup = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true && getConfigurationValue(agentIdentifier, 'session_trace.enabled') === true;
@@ -85,7 +96,7 @@ export class Aggregate extends AggregateBase {
       });
 
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
-      this.scheduler = new HarvestScheduler('blob', {
+      this.scheduler = new HarvestScheduler('browser/blobs', {
         onFinished: this.onHarvestFinished.bind(this),
         retryDelay: this.harvestTimeSeconds,
         getPayload: this.prepareHarvest.bind(this),
@@ -105,10 +116,9 @@ export class Aggregate extends AggregateBase {
             this.stopRecording();
             this.startRecording();
             this.scheduler.startTimer(this.harvestTimeSeconds);
-            const {
-              session
-            } = getRuntime(this.agentIdentifier);
-            session.state.sessionReplay = this.mode;
+            this.syncWithSessionManager({
+              sessionReplay: this.mode
+            });
           }
         }
       }, this.featureName, this.ee);
@@ -181,17 +191,18 @@ export class Aggregate extends AggregateBase {
     }
     this.startRecording();
     this.isFirstChunk = !!session.isNew;
-    session.state.sessionReplay = this.mode;
+    this.syncWithSessionManager({
+      sessionReplay: this.mode
+    });
   }
   prepareHarvest() {
-    if (this.events.length === 0) return;
+    if (this.events.length === 0 || this.mode !== MODE.FULL && !this.blocked) return;
     const payload = this.getHarvestContents();
     if (this.shouldCompress) {
       payload.body = gzipper(u8(stringify(payload.body)));
       this.scheduler.opts.gzip = true;
     } else {
       this.scheduler.opts.gzip = false;
-      delete payload.qs.content_encoding;
     }
     // TODO -- Gracefully handle the buffer for retries.
     this.clearBuffer();
@@ -202,25 +213,28 @@ export class Aggregate extends AggregateBase {
     const info = getInfo(this.agentIdentifier);
     return {
       qs: {
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      },
-      body: {
+        browser_monitoring_key: info.licenseKey,
         type: 'SessionReplay',
-        appId: Number(info.applicationID),
-        timestamp: Date.now(),
-        blob: JSON.stringify(this.events),
-        // this needs to be a stringified JSON array of rrweb nodes
-        attributes: {
+        app_id: info.applicationID,
+        protocol_version: '0',
+        attributes: encodeObj({
+          ...(this.shouldCompress && {
+            content_encoding: 'gzip'
+          }),
+          'replay.firstTimestamp': this.timestamp.first,
+          'replay.lastTimestamp': this.timestamp.last,
+          'replay.durationMs': this.timestamp.last - this.timestamp.first,
+          agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
-          agentVersion: agentRuntime.version,
           isFirstChunk: this.isFirstChunk,
+          decompressedBytes: this.payloadBytesEstimation,
           'nr.rrweb.version': RRWEB_VERSION
-        }
-      }
+        }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
+      },
+
+      body: this.events
     };
   }
   onHarvestFinished(result) {
@@ -238,6 +252,7 @@ export class Aggregate extends AggregateBase {
     this.hasSnapshot = false;
     this.hasError = false;
     this.payloadBytesEstimation = 0;
+    this.clearTimestamps();
   }
 
   /** Begin recording using configured recording lib */
@@ -246,6 +261,7 @@ export class Aggregate extends AggregateBase {
       warn('Recording library was never imported');
       return this.abort();
     }
+    this.recording = true;
     const {
       blockClass,
       ignoreClass,
@@ -255,7 +271,6 @@ export class Aggregate extends AggregateBase {
       maskTextSelector,
       maskAllInputs
     } = getConfigurationValue(this.agentIdentifier, 'session_replay');
-    this.hasSnapshot = true;
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
     const stop = recorder({
@@ -267,11 +282,8 @@ export class Aggregate extends AggregateBase {
       maskInputOptions,
       maskTextSelector,
       maskAllInputs,
-      ...(this.mode === MODE.ERROR && {
-        checkoutEveryNms: CHECKOUT_MS
-      })
+      checkoutEveryNms: CHECKOUT_MS[this.mode]
     });
-    this.recording = true;
     this.stopRecording = () => {
       this.recording = false;
       stop();
@@ -296,12 +308,14 @@ export class Aggregate extends AggregateBase {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
+    this.setTimestamps(event);
+    if (event.type === 2) this.hasSnapshot = true;
     this.events.push(event);
     this.payloadBytesEstimation += eventBytes;
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if (payloadSize > IDEAL_PAYLOAD_SIZE) {
+    if (payloadSize > IDEAL_PAYLOAD_SIZE && this.mode !== MODE.ERROR) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
       this.scheduler.runHarvest();
     }
@@ -311,7 +325,17 @@ export class Aggregate extends AggregateBase {
   takeFullSnapshot() {
     if (!recorder) return;
     recorder.takeFullSnapshot();
-    this.hasSnapshot = true;
+  }
+  setTimestamps(rrwebEvent) {
+    if (!rrwebEvent) return;
+    if (!this.timestamp.first) this.timestamp.first = rrwebEvent.timestamp;
+    this.timestamp.last = rrwebEvent.timestamp;
+  }
+  clearTimestamps() {
+    this.timestamp = {
+      first: undefined,
+      last: undefined
+    };
   }
 
   /** Estimate the payload size */
@@ -326,11 +350,11 @@ export class Aggregate extends AggregateBase {
     this.blocked = true;
     this.mode = MODE.OFF;
     this.stopRecording();
+    this.syncWithSessionManager({
+      sessionReplay: this.mode
+    });
+    this.clearTimestamps();
     this.ee.emit('REPLAY_ABORTED');
-    const {
-      session
-    } = getRuntime(this.agentIdentifier);
-    session.state.sessionReplay = this.mode;
   }
 
   /** Extensive research has yielded about an 88% compression factor on these payloads.
@@ -341,4 +365,11 @@ export class Aggregate extends AggregateBase {
     if (this.shouldCompress) return data * AVG_COMPRESSION;
     return data;
   }
+  syncWithSessionManager() {
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      session
+    } = getRuntime(this.agentIdentifier);
+    session.write(state);
+  }
 }

package/dist/esm/features/session_trace/aggregate/index.js

@@ -109,8 +109,8 @@ export class Aggregate extends AggregateBase {
           sessionTraceMode: MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        this.#scheduler?.stopTimer(true);
         if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        this.#scheduler?.stopTimer(true); // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null;
       };
 
@@ -136,9 +136,8 @@ export class Aggregate extends AggregateBase {
           this.ee.on(SESSION_EVENTS.PAUSE, () => mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           if (!sessionEntity.isNew) {
             // inherit the same mode as existing session's Trace
-            const existingTraceMode = mostRecentModeKnown = sessionEntity.state.sessionTraceMode;
-            if (existingTraceMode === MODE.OFF) this.isStandalone = true;
-            controlTraceOp(existingTraceMode);
+            if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true;
+            controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           } else {
             // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
             const replayMode = await getSessionReplayMode(agentIdentifier);

package/dist/esm/features/spa/aggregate/index.js

@@ -398,7 +398,7 @@ export class Aggregate extends AggregateBase {
     register(FETCH_DONE, function (err, res) {
       var node = this[SPA_NODE];
       if (node) {
-        if (err) {
+        if (err || !shouldCollectEvent(this.params)) {
           node.cancel();
           return;
         }

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

@@ -10,7 +10,7 @@ import { onWindowLoad } from '../../common/window/load';
 import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
-import { getConfigurationValue } from '../../common/config/config';
+import { getConfigurationValue, originals } from '../../common/config/config';
 
 /**
  * Base class for instrumenting a feature.
@@ -56,7 +56,7 @@ export class InstrumentBase extends FeatureBase {
     let argsObjFromInstrument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     if (this.featAggregate || !this.auto) return;
     const enableSessionTracking = isBrowserScope && getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true;
-    let loadedSuccessfully, loadFailed;
+    let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;
     });
@@ -81,6 +81,7 @@ export class InstrumentBase extends FeatureBase {
       try {
         if (!this.shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName);
+          loadedSuccessfully(false); // aggregate module isn't loaded at all
           return;
         }
         const {
@@ -111,15 +112,12 @@ export class InstrumentBase extends FeatureBase {
   * @returns
   */
   shouldImportAgg(featureName, session) {
-    // if this isnt the FIRST load of a session AND
-    // we are not actively recording SR... DO NOT run the aggregator
-    // session replay samples can only be decided on the first load of a session
-    // session replays can continue if in progress
     if (featureName === FEATURE_NAMES.sessionReplay) {
-      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false;
-      return !!session?.isNew || !!session?.state.sessionReplay;
+      if (!originals.MO) return false; // Session Replay cannot work without Mutation Observer
+      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false; // Session Replay as of now is tightly coupled with Session Trace in the UI
+      return !!session?.isNew || !!session?.state.sessionReplay; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
     }
-    // todo -- add case like above for session trace
+
     return true;
   }
 }

package/dist/esm/loaders/agent-base.js

@@ -0,0 +1,80 @@
+import { warn } from '../common/util/console';
+export class AgentBase {
+  /**
+   * Reports a browser PageAction event along with a name and optional attributes.
+   * {@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) {
+    warn('Call to agent api addPageAction failed. The session trace feature is not currently initialized.');
+  }
+
+  /**
+   * Groups page views to help URL structure or to capture the URL's routing information.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setpageviewname/}
+   * @param {string} name The page name you want to use. Use alphanumeric characters.
+   * @param {string} [host] Default is http://custom.transaction. Typically set host to your site's domain URI.
+   */
+  setPageViewName(name, host) {
+    warn('Call to agent api setPageViewName failed. The page view feature is not currently initialized.');
+  }
+
+  /**
+   * Adds a user-defined attribute name and value to subsequent events on the page.
+   * {@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|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 and Integers.
+   * @param {boolean} [persist] Default false. f 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) {
+    warn('Call to agent api setCustomAttribute failed. The js errors feature is not currently initialized.');
+  }
+
+  /**
+   * Identifies a browser error without disrupting your app's operations.
+   * {@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) {
+    warn('Call to agent api noticeError failed. The js errors feature is not currently initialized.');
+  }
+
+  /**
+   * Adds a user-defined identifier string to subsequent events on the page.
+   * {@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.
+   */
+  setUserId(value) {
+    warn('Call to agent api setUserId failed. The js errors feature is not currently initialized.');
+  }
+
+  /**
+   * Allows selective ignoring and grouping of known errors that the browser agent captures.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/seterrorhandler/}
+   * @param {(error: Error|string) => boolean | { group: string }} callback When an error occurs, the callback is called with the error object as a parameter. The callback will be called with each error, so it is not specific to one error.
+   */
+  setErrorHandler(callback) {
+    warn('Call to agent api setErrorHandler failed. The js errors feature is not currently initialized.');
+  }
+
+  /**
+   * Records an additional time point as "finished" in a session trace, and sends the event to New Relic.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/finished/}
+   * @param {number} [timeStamp] Defaults to the current time of the call. If used, this marks the time that the page is "finished" according to your own criteria.
+   */
+  finished(timeStamp) {
+    warn('Call to agent api finished failed. The page action feature is not currently initialized.');
+  }
+
+  /**
+   * Adds a unique name and ID to identify releases with multiple JavaScript bundles on the same page.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addrelease/}
+   * @param {string} name A short description of the component; for example, the name of a project, application, file, or library.
+   * @param {string} id The ID or version of this release; for example, a version number, build number from your CI environment, GitHub SHA, GUID, or a hash of the contents.
+   */
+  addRelease(name, id) {
+    warn('Call to agent api addRelease failed. The agent is not currently initialized.');
+  }
+}

package/dist/esm/loaders/agent.js

@@ -1,4 +1,5 @@
 // loader files
+import { AgentBase } from './agent-base';
 import { getEnabledFeatures } from './features/enabled-features';
 import { configure } from './configure/configure';
 import { getFeatureDependencyNames } from './features/featureDependencies';
@@ -14,13 +15,18 @@ import { warn } from '../common/util/console';
 import { stringify } from '../common/util/stringify';
 import { globalScope } from '../common/constants/runtime';
 
+/**
+ * @typedef {import('./api/interaction-types').InteractionInstance} InteractionInstance
+ */
+
 /**
  * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
-export class Agent {
+export class Agent extends AgentBase {
   constructor(options) {
     let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
+    super();
     if (!globalScope) {
       // We could not determine the runtime environment. Short-circuite the agent here
       // to avoid possible exceptions later that may cause issues with customer's application.
@@ -81,4 +87,38 @@ export class Agent {
       return false;
     }
   }
+
+  /* Below API methods are only available on a standard agent and not the micro agent */
+
+  /**
+   * Adds a JavaScript object with a custom name, start time, etc. to an in-progress session trace.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addtotrace/}
+   * @param {{name: string, start: number, end?: number, origin?: string, type?: string}} customAttributes Supply a JavaScript object with these required and optional name/value pairs:
+   *
+   * - Required name/value pairs: name, start
+   * - Optional name/value pairs: end, origin, type
+   *
+   * If you are sending the same event object to New Relic as a PageAction, omit the TYPE attribute. (type is a string to describe what type of event you are marking inside of a session trace.) If included, it will override the event type and cause the PageAction event to be sent incorrectly. Instead, use the name attribute for event information.
+   */
+  addToTrace(customAttributes) {
+    warn('Call to agent api addToTrace failed. The page action feature is not currently initialized.');
+  }
+
+  /**
+   * Gives SPA routes more accurate names than default names. Monitors specific routes rather than by default grouping.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setcurrentroutename/}
+   * @param {string} name Current route name for the page.
+   */
+  setCurrentRouteName(name) {
+    warn('Call to agent api setCurrentRouteName failed. The spa feature is not currently initialized.');
+  }
+
+  /**
+   * Returns a new API object that is bound to the current SPA interaction.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/interaction/}
+   * @returns {InteractionInstance} An API object that is bound to a specific BrowserInteraction event. Each time this method is called for the same BrowserInteraction, a new object is created, but it still references the same interaction.
+   */
+  interaction() {
+    warn('Call to agent api interaction failed. The spa feature is not currently initialized.');
+  }
 }

package/dist/esm/loaders/api/api.js

@@ -122,7 +122,7 @@ export function setAPI(agentIdentifier, forceDrain) {
           try {
             return cb.apply(this, arguments);
           } catch (err) {
-            tracerEE.emit('fn-err', [arguments, this, typeof err == 'string' ? new Error(err) : err], contextStore);
+            tracerEE.emit('fn-err', [arguments, this, err], contextStore);
             // the error came from outside the agent, so don't swallow
             throw err;
           } finally {

package/dist/esm/loaders/api/interaction-types.js

@@ -0,0 +1,80 @@
+/**
+ * @typedef InteractionInstance
+ * @property {actionText} actionText
+ * @property {createTracer} createTracer
+ * @property {end} end
+ * @property {getContext} getContext
+ * @property {ignore} ignore
+ * @property {onEnd} onEnd
+ * @property {onEnd} save
+ * @property {setAttribute} setAttribute
+ * @property {setName} setName
+ */
+
+/**
+ * Sets the text value of the HTML element that was clicked to start a browser interaction.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/actiontext/}
+ * @callback actionText
+ * @param {string} value The text value of the HTML element that represents the action that started the interaction.
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Times sub-components of a SPA interaction separately, including wait time and JS execution time.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/createtracer/}
+ * @callback createTracer
+ * @param {string} name This will be used as the name of the tracer.
+ * @param {string} [callback] A callback that contains the synchronous work to run at the end of the async work. To execute this callback, call the wrapper function returned using createTracer().
+ * @returns {Function} Returns a method that wraps the original callback. When this method is invoked, it calls the original callback and ends the async timing.
+ */
+
+/**
+ * Ends the SPA interaction at the current time.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/end/}
+ * @callback end
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Stores values for the current SPA interaction asynchronously in browser.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/getcontext/}
+ * @callback getContext
+ * @param {(ctx: object) => void} callback This function is called when the interaction ends. It is called with one parameter, which is the interaction context.
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Change the values associated with a SPA interaction before the interaction is saved.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/onend/}
+ * @callback onEnd
+ * @param {(ctx: object) => void} callback This function is called when the interaction ends. It is called with one parameter, which is the interaction context.
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Ensures a SPA browser interaction will be saved when it ends.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/save/}
+ * @callback save
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Adds a custom SPA attribute only to the current interaction in browser.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setattribute/}
+ * @callback setAttribute
+ * @param {string} key Used as the attribute name on the BrowserInteraction event.
+ * @param {any} key Used as the attribute value on the BrowserInteraction event. This can be a string, number, boolean, or object. If it is an object, New Relic serializes it to a JSON string.
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/**
+ * Sets the name and trigger of a SPA's browser interaction that is not a route change or URL change.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setname/}
+ * @callback setName
+ * @param {string} name If null, the name will be set using the targetGroupedUrl attribute. If not null, this will set the browserInteractionName attribute in the BrowserInteraction event.
+ * @param {string} [trigger] If not null, this will set the TRIGGER attribute on the BrowserInteraction event.
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
+/* istanbul ignore next */
+export const unused = {};

package/dist/esm/loaders/configure/configure.js

@@ -1,7 +1,7 @@
 import { setAPI, setTopLevelCallers } from '../api/api';
 import { addToNREUM, gosCDN, gosNREUMInitializedAgents } from '../../common/window/nreum';
-import { setConfiguration, setInfo, setLoaderConfig, setRuntime } from '../../common/config/config';
-import { activateFeatures, activatedFeatures } from '../../common/util/feature-flags';
+import { getConfiguration, setConfiguration, setInfo, setLoaderConfig, setRuntime } from '../../common/config/config';
+import { activatedFeatures } from '../../common/util/feature-flags';
 import { isWorkerScope } from '../../common/constants/runtime';
 export function configure(agentIdentifier) {
   let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -24,13 +24,15 @@ export function configure(agentIdentifier) {
   }
   setConfiguration(agentIdentifier, init || {});
   setLoaderConfig(agentIdentifier, loader_config || {});
-  setRuntime(agentIdentifier, runtime);
   info.jsAttributes ??= {};
   if (isWorkerScope) {
     // add a default attr to all worker payloads
     info.jsAttributes.isWorker = true;
   }
   setInfo(agentIdentifier, info);
+  const updatedInit = getConfiguration(agentIdentifier);
+  runtime.denyList = [...(updatedInit.ajax?.deny_list || []), ...(updatedInit.ajax?.block_internal ? [info.beacon, info.errorBeacon] : [])];
+  setRuntime(agentIdentifier, runtime);
   setTopLevelCallers();
   const api = setAPI(agentIdentifier, forceDrain);
   gosNREUMInitializedAgents(agentIdentifier, api, 'api');

package/dist/esm/loaders/micro-agent.js

@@ -10,6 +10,7 @@ import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../commo
 import { FEATURE_NAMES } from './features/features';
 import { warn } from '../common/util/console';
 import { onWindowLoad } from '../common/window/load';
+import { AgentBase } from './agent-base';
 const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.pageAction, FEATURE_NAMES.metrics];
 
 /**
@@ -17,13 +18,14 @@ const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.pageAction, FEATU
  * automatically instrument. Instead, each MicroAgent instance will lazy load the required features and can support loading multiple instances on one page.
  * Out of the box, it can manually handle and report Page View, Page Action, and Error events.
  */
-export class MicroAgent {
+export class MicroAgent extends AgentBase {
   /**
    * @param {Object} options - Specifies features and runtime configuration,
    * @param {string=} agentIdentifier - The optional unique ID of the agent.
    */
   constructor(options) {
     let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
+    super();
     this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new Aggregator({
       agentIdentifier: this.agentIdentifier

package/dist/types/common/config/state/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/runtime.js"],"names":[],"mappings":"AA6BA,yCAIC;AAED,oDAIC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/runtime.js"],"names":[],"mappings":"AA8BA,yCAIC;AAED,oDAIC"}

package/dist/types/common/event-emitter/register-handler.d.ts

@@ -1,7 +1,7 @@
 export function defaultRegister(type: any, handler: any, group: any, ee: any): void;
 export namespace defaultRegister {
     export { registerWithSpecificEmitter as on };
-    export const handlers: {};
+    export let handlers: {};
 }
 export { defaultRegister as registerHandler };
 declare function registerWithSpecificEmitter(ee: any, handlers: any, type: any, handler: any, group: any): void;

package/dist/types/common/harvest/harvest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AAEH;IAII,0BAA2H;IAC3H,uBAAoD;IACpD,kCAAsH;IAEtH,YAAiB;IAGnB;;;;;OAKG;IACH,aAFW,eAAe,WAUzB;IAED;;;OAGG;IACH,YAFW,eAAe,WAMzB;IAED;;;OAGG;IACH,wBAFW,eAAe,WAMzB;IAED;;;;;;OAMG;IACH,gGAJW,eAAe,GACb,OAAO,CA8FnB;IAGD,0BAmBC;IAED;;;;;;;OAOG;IACH,wBALW,yBAAyB,WACzB,6BAA6B,GAE3B,cAAc,CA2B1B;IAED;;;;;;;OAOG;IACH,uBAHW,cAAc,GACZ,cAAc,CAwB1B;IAED;;;;;OAKG;IACH,aAHW,yBAAyB,YACzB,sBAAsB,QAQhC;CACF;8BAhQY,OAAO,YAAY,EAAE,eAAe;wCACpC,OAAO,YAAY,EAAE,yBAAyB;6BAC9C,OAAO,YAAY,EAAE,cAAc;qCACnC,OAAO,YAAY,EAAE,sBAAsB;4CAC3C,OAAO,YAAY,EAAE,6BAA6B;8BATjC,2BAA2B;2BAF9B,mBAAmB"}
+{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAsBA;;;;;;GAMG;AACH;IAII,0BAA2H;IAC3H,uBAAoD;IACpD,kCAAsH;IAEtH,YAAiB;IAGnB;;;;;OAKG;IACH,aAFW,eAAe,WAUzB;IAED;;;OAGG;IACH,YAFW,eAAe,WAMzB;IAED;;;OAGG;IACH,wBAFW,eAAe,WAMzB;IAED;;;;;;OAMG;IACH,gGAJW,eAAe,GACb,OAAO,CAmFnB;IAGD,0BAmBC;IAED;;;;;;;OAOG;IACH,wBALW,yBAAyB,WACzB,6BAA6B,GAE3B,cAAc,CA2B1B;IAED;;;;;;;OAOG;IACH,uBAHW,cAAc,GACZ,cAAc,CAuB1B;IAED;;;;;OAKG;IACH,aAHW,yBAAyB,YACzB,sBAAsB,QAQhC;CACF;8BAnPY,OAAO,YAAY,EAAE,eAAe;wCACpC,OAAO,YAAY,EAAE,yBAAyB;6BAC9C,OAAO,YAAY,EAAE,cAAc;qCACnC,OAAO,YAAY,EAAE,sBAAsB;4CAC3C,OAAO,YAAY,EAAE,6BAA6B;8BAZjC,2BAA2B;2BAF9B,mBAAmB"}

package/dist/types/common/session/session-entity.d.ts

@@ -1,12 +1,12 @@
 export namespace MODE {
-    const OFF: number;
-    const FULL: number;
-    const ERROR: number;
+    let OFF: number;
+    let FULL: number;
+    let ERROR: number;
 }
 export namespace SESSION_EVENTS {
-    const PAUSE: string;
-    const RESET: string;
-    const RESUME: string;
+    let PAUSE: string;
+    let RESET: string;
+    let RESUME: string;
 }
 export class SessionEntity {
     /**