@newrelic/browser-agent 1.236.0 → 1.237.0

package/dist/cjs/features/page_view_event/aggregate/initialized-features.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getActivatedFeaturesFlags = getActivatedFeaturesFlags;
 var _features = require("../../../loaders/features/features");
+var _nreum = require("../../../common/window/nreum");
 /**
  * Get an array of flags required by downstream (NR UI) based on the features initialized in this agent
  * (aka what is running on the page).
@@ -13,25 +14,28 @@ var _features = require("../../../loaders/features/features");
  */
 function getActivatedFeaturesFlags(agentId) {
   const flagArr = [];
-  Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
-    switch (featName) {
-      case _features.FEATURE_NAMES.ajax:
-        flagArr.push('xhr');
-        break;
-      case _features.FEATURE_NAMES.jserrors:
-        flagArr.push('err');
-        break;
-      case _features.FEATURE_NAMES.pageAction:
-        flagArr.push('ins');
-        break;
-      case _features.FEATURE_NAMES.sessionTrace:
-        flagArr.push('stn');
-        break;
-      case _features.FEATURE_NAMES.spa:
-        flagArr.push('spa');
-        break;
-    }
-  });
+  const newrelic = (0, _nreum.gosNREUM)();
+  try {
+    Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
+      switch (featName) {
+        case _features.FEATURE_NAMES.ajax:
+          flagArr.push('xhr');
+          break;
+        case _features.FEATURE_NAMES.jserrors:
+          flagArr.push('err');
+          break;
+        case _features.FEATURE_NAMES.pageAction:
+          flagArr.push('ins');
+          break;
+        case _features.FEATURE_NAMES.sessionTrace:
+          flagArr.push('stn');
+          break;
+        case _features.FEATURE_NAMES.spa:
+          flagArr.push('spa');
+          break;
+      }
+    });
+  } catch (e) {}
   return flagArr;
 }
 

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

@@ -13,6 +13,7 @@ var _config = require("../../../common/config/config");
 var _sessionEntity = require("../../../common/session/session-entity");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _sharedChannel = require("../../../common/constants/shared-channel");
+var _encode = require("../../../common/url/encode");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } /*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       * Copyright 2023 New Relic Corporation. All rights reserved.
@@ -36,9 +37,13 @@ const MAX_PAYLOAD_SIZE = 1000000;
 /** Unloading caps around 64kb */
 exports.MAX_PAYLOAD_SIZE = MAX_PAYLOAD_SIZE;
 const IDEAL_PAYLOAD_SIZE = 64000;
-/** Interval between forcing new full snapshots in "error" mode */
+/** Interval between forcing new full snapshots -- 30 seconds in error mode, 5 minutes in full mode */
 exports.IDEAL_PAYLOAD_SIZE = IDEAL_PAYLOAD_SIZE;
-const CHECKOUT_MS = 30000;
+const CHECKOUT_MS = {
+  [_sessionEntity.MODE.ERROR]: 30000,
+  [_sessionEntity.MODE.FULL]: 300000,
+  [_sessionEntity.MODE.OFF]: 0
+};
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -70,6 +75,12 @@ class Aggregate extends _aggregateBase.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 = (0, _config.getConfigurationValue)(agentIdentifier, 'privacy.cookies_enabled') === true && (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.enabled') === true;
@@ -93,7 +104,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       });
 
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
-      this.scheduler = new _harvestScheduler.HarvestScheduler('blob', {
+      this.scheduler = new _harvestScheduler.HarvestScheduler('browser/blobs', {
         onFinished: this.onHarvestFinished.bind(this),
         retryDelay: this.harvestTimeSeconds,
         getPayload: this.prepareHarvest.bind(this),
@@ -113,10 +124,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
             this.stopRecording();
             this.startRecording();
             this.scheduler.startTimer(this.harvestTimeSeconds);
-            const {
-              session
-            } = (0, _config.getRuntime)(this.agentIdentifier);
-            session.state.sessionReplay = this.mode;
+            this.syncWithSessionManager({
+              sessionReplay: this.mode
+            });
           }
         }
       }, this.featureName, this.ee);
@@ -189,17 +199,18 @@ class Aggregate extends _aggregateBase.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 !== _sessionEntity.MODE.FULL && !this.blocked) return;
     const payload = this.getHarvestContents();
     if (this.shouldCompress) {
       payload.body = gzipper(u8((0, _stringify.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();
@@ -210,25 +221,28 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const info = (0, _config.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: (0, _encode.obj)({
+          ...(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) {
@@ -246,6 +260,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.hasSnapshot = false;
     this.hasError = false;
     this.payloadBytesEstimation = 0;
+    this.clearTimestamps();
   }
 
   /** Begin recording using configured recording lib */
@@ -254,6 +269,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       warn('Recording library was never imported');
       return this.abort();
     }
+    this.recording = true;
     const {
       blockClass,
       ignoreClass,
@@ -263,7 +279,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       maskTextSelector,
       maskAllInputs
     } = (0, _config.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({
@@ -275,11 +290,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       maskInputOptions,
       maskTextSelector,
       maskAllInputs,
-      ...(this.mode === _sessionEntity.MODE.ERROR && {
-        checkoutEveryNms: CHECKOUT_MS
-      })
+      checkoutEveryNms: CHECKOUT_MS[this.mode]
     });
-    this.recording = true;
     this.stopRecording = () => {
       this.recording = false;
       stop();
@@ -304,12 +316,14 @@ class Aggregate extends _aggregateBase.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 !== _sessionEntity.MODE.ERROR) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
       this.scheduler.runHarvest();
     }
@@ -319,7 +333,17 @@ class Aggregate extends _aggregateBase.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 */
@@ -334,11 +358,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.blocked = true;
     this.mode = _sessionEntity.MODE.OFF;
     this.stopRecording();
+    this.syncWithSessionManager({
+      sessionReplay: this.mode
+    });
+    this.clearTimestamps();
     this.ee.emit('REPLAY_ABORTED');
-    const {
-      session
-    } = (0, _config.getRuntime)(this.agentIdentifier);
-    session.state.sessionReplay = this.mode;
   }
 
   /** Extensive research has yielded about an 88% compression factor on these payloads.
@@ -349,5 +373,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (this.shouldCompress) return data * AVG_COMPRESSION;
     return data;
   }
+  syncWithSessionManager() {
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      session
+    } = (0, _config.getRuntime)(this.agentIdentifier);
+    session.write(state);
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -116,8 +116,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
           sessionTraceMode: _sessionEntity.MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        this.#scheduler?.stopTimer(true);
         if (mostRecentModeKnown === _sessionEntity.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;
       };
 
@@ -143,9 +143,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
           this.ee.on(_sessionEntity.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 === _sessionEntity.MODE.OFF) this.isStandalone = true;
-            controlTraceOp(existingTraceMode);
+            if (sessionEntity.state.sessionReplay === _sessionEntity.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 (0, _replayMode.getSessionReplayMode)(agentIdentifier);

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

@@ -61,7 +61,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
     let argsObjFromInstrument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     if (this.featAggregate || !this.auto) return;
     const enableSessionTracking = _runtime.isBrowserScope && (0, _config.getConfigurationValue)(this.agentIdentifier, 'privacy.cookies_enabled') === true;
-    let loadedSuccessfully, loadFailed;
+    let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;
     });
@@ -86,6 +86,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
       try {
         if (!this.shouldImportAgg(this.featureName, session)) {
           (0, _drain.drain)(this.agentIdentifier, this.featureName);
+          loadedSuccessfully(false); // aggregate module isn't loaded at all
           return;
         }
         const {
@@ -116,15 +117,12 @@ class InstrumentBase extends _featureBase.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 === _features.FEATURE_NAMES.sessionReplay) {
-      if ((0, _config.getConfigurationValue)(this.agentIdentifier, 'session_trace.enabled') === false) return false;
-      return !!session?.isNew || !!session?.state.sessionReplay;
+      if (!_config.originals.MO) return false; // Session Replay cannot work without Mutation Observer
+      if ((0, _config.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/cjs/loaders/agent-base.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgentBase = void 0;
+var _console = require("../common/util/console");
+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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.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) {
+    (0, _console.warn)('Call to agent api addRelease failed. The agent is not currently initialized.');
+  }
+}
+exports.AgentBase = AgentBase;

package/dist/cjs/loaders/agent.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Agent = void 0;
+var _agentBase = require("./agent-base");
 var _enabledFeatures = require("./features/enabled-features");
 var _configure = require("./configure/configure");
 var _featureDependencies = require("./features/featureDependencies");
@@ -22,13 +23,18 @@ var _runtime = require("../common/constants/runtime");
 
 // common files
 
+/**
+ * @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.
  */
-class Agent {
+class Agent extends _agentBase.AgentBase {
   constructor(options) {
     let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _uniqueId.generateRandomHexString)(16);
+    super();
     if (!_runtime.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.
@@ -89,5 +95,39 @@ 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) {
+    (0, _console.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) {
+    (0, _console.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() {
+    (0, _console.warn)('Call to agent api interaction failed. The spa feature is not currently initialized.');
+  }
 }
 exports.Agent = Agent;

package/dist/cjs/loaders/api/api.js

@@ -131,7 +131,7 @@ 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/cjs/loaders/api/interaction-types.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unused = void 0;
+/**
+ * @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 */
+const unused = {};
+exports.unused = unused;

package/dist/cjs/loaders/configure/configure.js

@@ -30,13 +30,14 @@ function configure(agentIdentifier) {
   }
   (0, _config.setConfiguration)(agentIdentifier, init || {});
   (0, _config.setLoaderConfig)(agentIdentifier, loader_config || {});
-  (0, _config.setRuntime)(agentIdentifier, runtime);
   info.jsAttributes ??= {};
   if (_runtime.isWorkerScope) {
     // add a default attr to all worker payloads
     info.jsAttributes.isWorker = true;
   }
   (0, _config.setInfo)(agentIdentifier, info);
+  runtime.denyList = init.ajax?.block_internal ? (init.ajax.deny_list || []).concat(info.beacon, info.errorBeacon) : init.ajax?.deny_list;
+  (0, _config.setRuntime)(agentIdentifier, runtime);
   (0, _api.setTopLevelCallers)();
   const api = (0, _api.setAPI)(agentIdentifier, forceDrain);
   (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, api, 'api');

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

@@ -14,6 +14,7 @@ var _config = require("../common/config/config");
 var _features = require("./features/features");
 var _console = require("../common/util/console");
 var _load = require("../common/window/load");
+var _agentBase = require("./agent-base");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } // loader files
 // core files
@@ -24,13 +25,14 @@ const nonAutoFeatures = [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAM
  * 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.
  */
-class MicroAgent {
+class MicroAgent extends _agentBase.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] : (0, _uniqueId.generateRandomHexString)(16);
+    super();
     this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new _aggregator.Aggregator({
       agentIdentifier: this.agentIdentifier

package/dist/esm/common/config/state/init.js

@@ -17,6 +17,7 @@ const model = () => {
     // *cli - per discussion, default should be true
     ajax: {
       deny_list: undefined,
+      block_internal: true,
       enabled: true,
       harvestTimeSeconds: 10
     },

package/dist/esm/common/config/state/runtime.js

@@ -23,7 +23,8 @@ const model = {
   releaseIds: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  version: VERSION
+  version: VERSION,
+  denyList: undefined
 };
 const _cache = {};
 export function getRuntime(id) {