@newrelic/browser-agent 1.235.0 → 1.237.0

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_replay/replay-mode.js

@@ -20,8 +20,8 @@ async function getSessionReplayMode(agentId) {
     const newrelic = (0, _nreum.gosNREUM)();
     // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
     if ((0, _config.getConfigurationValue)(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
-      await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported; // if Replay could not initialize, this throws a (uncaught) rejection
-      return await _sharedChannel.sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
+      const srInitialized = await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported;
+      if (srInitialized) return await _sharedChannel.sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
     }
   } catch (e) {/* exception ==> off */}
   return _sessionEntity.MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off

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/session_trace/instrument/index.js

@@ -10,7 +10,7 @@ var _now = require("../../../common/timing/now");
 var _instrumentBase = require("../../utils/instrument-base");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _features = require("../../../loaders/features/features");
-var _globalScope = require("../../../common/util/global-scope");
+var _runtime = require("../../../common/constants/runtime");
 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; }
 /*
@@ -33,7 +33,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    if (!_globalScope.isBrowserScope) return; // session traces not supported outside web env
+    if (!_runtime.isBrowserScope) return; // session traces not supported outside web env
 
     const thisInstrumentEE = this.ee;
     (0, _wrap.wrapHistory)(thisInstrumentEE);

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

@@ -628,7 +628,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     function onHarvestFinished(result) {
       if (result.sent && result.retry && state.interactionsSent.length > 0) {
         state.interactionsSent.forEach(function (interaction) {
-          state.interactionsToHarvest.push(interaction);
+          state.interactionsToHarvest.unshift(interaction);
         });
         state.interactionsSent = [];
       }

package/dist/cjs/features/spa/instrument/index.js

@@ -10,7 +10,7 @@ var _instrumentBase = require("../../utils/instrument-base");
 var _config = require("../../../common/config/config");
 var _now = require("../../../common/timing/now");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
-var _globalScope = require("../../../common/util/global-scope");
+var _runtime = require("../../../common/constants/runtime");
 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; }
 /*
@@ -35,7 +35,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    if (!_globalScope.isBrowserScope) return; // SPA not supported outside web env
+    if (!_runtime.isBrowserScope) return; // SPA not supported outside web env
 
     if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
     try {

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

@@ -7,7 +7,7 @@ exports.InstrumentBase = void 0;
 var _drain = require("../../common/drain/drain");
 var _featureBase = require("./feature-base");
 var _load = require("../../common/window/load");
-var _globalScope = require("../../common/util/global-scope");
+var _runtime = require("../../common/constants/runtime");
 var _console = require("../../common/util/console");
 var _features = require("../../loaders/features/features");
 var _config = require("../../common/config/config");
@@ -60,11 +60,10 @@ class InstrumentBase extends _featureBase.FeatureBase {
   importAggregator() {
     let argsObjFromInstrument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     if (this.featAggregate || !this.auto) return;
-    const enableSessionTracking = _globalScope.isBrowserScope && (0, _config.getConfigurationValue)(this.agentIdentifier, 'privacy.cookies_enabled') === true;
-    let loadedSuccessfully, loadFailed;
-    this.onAggregateImported = new Promise((resolve, reject) => {
+    const enableSessionTracking = _runtime.isBrowserScope && (0, _config.getConfigurationValue)(this.agentIdentifier, 'privacy.cookies_enabled') === true;
+    let loadedSuccessfully;
+    this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;
-      loadFailed = reject;
     });
     const importLater = async () => {
       let session;
@@ -87,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 {
@@ -96,18 +96,18 @@ class InstrumentBase extends _featureBase.FeatureBase {
           Aggregate
         } = await lazyFeatureLoader(this.featureName, 'aggregate');
         this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument);
-        loadedSuccessfully();
+        loadedSuccessfully(true);
       } catch (e) {
         (0, _console.warn)("Downloading and initializing ".concat(this.featureName, " failed..."), e);
         this.abortHandler?.(); // undo any important alterations made to the page
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
-        loadFailed();
+        loadedSuccessfully(false);
       }
     };
 
     // For regular web pages, we want to wait and lazy-load the aggregator only after all page resources are loaded.
     // Non-browser scopes (i.e. workers) have no `window.load` event, so the aggregator can be lazy-loaded immediately.
-    if (!_globalScope.isBrowserScope) importLater();else (0, _load.onWindowLoad)(() => importLater(), true);
+    if (!_runtime.isBrowserScope) importLater();else (0, _load.onWindowLoad)(() => importLater(), true);
   }
 
   /**
@@ -117,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/index.js

@@ -33,6 +33,12 @@ Object.defineProperty(exports, "Metrics", {
     return _metrics.Metrics;
   }
 });
+Object.defineProperty(exports, "MicroAgent", {
+  enumerable: true,
+  get: function () {
+    return _microAgent.MicroAgent;
+  }
+});
 Object.defineProperty(exports, "PageAction", {
   enumerable: true,
   get: function () {
@@ -72,6 +78,7 @@ Object.defineProperty(exports, "WorkerAgent", {
 var _agent = require("./loaders/agent");
 var _browserAgent = require("./loaders/browser-agent");
 var _workerAgent = require("./loaders/worker-agent");
+var _microAgent = require("./loaders/micro-agent");
 var _ajax = require("./features/ajax");
 var _jserrors = require("./features/jserrors");
 var _metrics = require("./features/metrics");

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");
@@ -15,19 +16,31 @@ var _uniqueId = require("../common/ids/unique-id");
 var _config = require("../common/config/config");
 var _console = require("../common/util/console");
 var _stringify = require("../common/util/stringify");
+var _runtime = require("../common/constants/runtime");
 // loader files
 
 // required features
 
 // 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.
+      (0, _console.warn)('Failed to initial the agent. Could not determine the runtime environment.');
+      return;
+    }
     this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new _aggregator.Aggregator({
       agentIdentifier: this.agentIdentifier
@@ -82,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

@@ -13,7 +13,7 @@ var _contextualEe = require("../../common/event-emitter/contextual-ee");
 var _now = require("../../common/timing/now");
 var _drain = require("../../common/drain/drain");
 var _load = require("../../common/window/load");
-var _globalScope = require("../../common/util/global-scope");
+var _runtime = require("../../common/constants/runtime");
 var _console = require("../../common/util/console");
 var _constants = require("../../features/metrics/constants");
 var _nreum = require("../../common/window/nreum");
@@ -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 {
@@ -158,7 +158,7 @@ function setAPI(agentIdentifier, forceDrain) {
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately
-  if (!_globalScope.isBrowserScope) lazyLoad();
+  if (!_runtime.isBrowserScope) lazyLoad();
   // try to stay out of the way of the window.load event, lazy load once that has finished.
   else (0, _load.onWindowLoad)(() => lazyLoad(), true);
   function lazyLoad() {

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

@@ -10,9 +10,11 @@ var _contextualEe = require("../../common/event-emitter/contextual-ee");
 var _handle = require("../../common/event-emitter/handle");
 var _registerHandler = require("../../common/event-emitter/register-handler");
 var _invoke = require("../../common/util/invoke");
-var _submitData = require("../../common/util/submit-data");
-var _globalScope = require("../../common/util/global-scope");
+var submitData = _interopRequireWildcard(require("../../common/util/submit-data"));
+var _runtime = require("../../common/constants/runtime");
 var _constants = require("../../features/metrics/constants");
+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; }
 function setAPI(agentIdentifier) {
   var instanceEE = _contextualEe.ee.get(agentIdentifier);
   var cycle = 0;
@@ -67,7 +69,7 @@ function setAPI(agentIdentifier) {
   // dom_time - the time spent processing the result of the service call (or user defined)
   // fe_time - the time spent rendering the result of the service call (or user defined)
   function inlineHit(t, request_name, queue_time, app_time, total_be_time, dom_time, fe_time) {
-    if (!_globalScope.isBrowserScope) return;
+    if (!_runtime.isBrowserScope) return;
     request_name = window.encodeURIComponent(request_name);
     cycle += 1;
     const agentInfo = (0, _config.getInfo)(agentIdentifier);
@@ -82,7 +84,7 @@ function setAPI(agentIdentifier) {
     url += 'dc=' + ~~dom_time + '&';
     url += 'fe=' + ~~fe_time + '&';
     url += 'c=' + cycle;
-    _submitData.submitData.img({
+    submitData.xhr({
       url
     });
   }