@newrelic/browser-agent 1.237.1 → 1.239.0

package/dist/esm/features/metrics/aggregate/framework-detection.js

@@ -1,31 +1,59 @@
 import { isBrowserScope } from '../../../common/constants/runtime';
 const FRAMEWORKS = {
   REACT: 'React',
+  NEXTJS: 'NextJS',
+  VUE: 'Vue',
+  NUXTJS: 'NuxtJS',
   ANGULAR: 'Angular',
+  ANGULARUNIVERSAL: 'AngularUniversal',
+  SVELTE: 'Svelte',
+  SVELTEKIT: 'SvelteKit',
+  PREACT: 'Preact',
+  PREACTSSR: 'PreactSSR',
   ANGULARJS: 'AngularJS',
   BACKBONE: 'Backbone',
   EMBER: 'Ember',
-  VUE: 'Vue',
   METEOR: 'Meteor',
   ZEPTO: 'Zepto',
   JQUERY: 'Jquery',
-  MOOTOOLS: 'MooTools'
+  MOOTOOLS: 'MooTools',
+  QWIK: 'Qwik',
+  ELECTRON: 'Electron'
 };
 export function getFrameworks() {
   if (!isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
 
   const frameworks = [];
   try {
-    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
+    if (detectReact()) {
+      frameworks.push(FRAMEWORKS.REACT);
+      if (detectNextJS()) frameworks.push(FRAMEWORKS.NEXTJS);
+    }
+    if (detectVue()) {
+      frameworks.push(FRAMEWORKS.VUE);
+      if (detectNuxtJS()) frameworks.push(FRAMEWORKS.NUXTJS);
+    }
+    if (detectAngular()) {
+      frameworks.push(FRAMEWORKS.ANGULAR);
+      if (detectAngularUniversal()) frameworks.push(FRAMEWORKS.ANGULARUNIVERSAL);
+    }
+    if (detectSvelte()) {
+      frameworks.push(FRAMEWORKS.SVELTE);
+      if (detectSvelteKit()) frameworks.push(FRAMEWORKS.SVELTEKIT);
+    }
+    if (detectPreact()) {
+      frameworks.push(FRAMEWORKS.PREACT);
+      if (detectPreactSSR()) frameworks.push(FRAMEWORKS.PREACTSSR);
+    }
     if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
-    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
     if (Object.prototype.hasOwnProperty.call(window, 'Backbone')) frameworks.push(FRAMEWORKS.BACKBONE);
     if (Object.prototype.hasOwnProperty.call(window, 'Ember')) frameworks.push(FRAMEWORKS.EMBER);
-    if (Object.prototype.hasOwnProperty.call(window, 'Vue')) frameworks.push(FRAMEWORKS.VUE);
     if (Object.prototype.hasOwnProperty.call(window, 'Meteor')) frameworks.push(FRAMEWORKS.METEOR);
     if (Object.prototype.hasOwnProperty.call(window, 'Zepto')) frameworks.push(FRAMEWORKS.ZEPTO);
     if (Object.prototype.hasOwnProperty.call(window, 'jQuery')) frameworks.push(FRAMEWORKS.JQUERY);
     if (Object.prototype.hasOwnProperty.call(window, 'MooTools')) frameworks.push(FRAMEWORKS.MOOTOOLS);
+    if (Object.prototype.hasOwnProperty.call(window, 'qwikevents')) frameworks.push(FRAMEWORKS.QWIK);
+    if (detectElectron()) frameworks.push(FRAMEWORKS.ELECTRON);
   } catch (err) {
     // Possibly not supported
   }
@@ -45,9 +73,25 @@ function detectReact() {
     return false;
   }
 }
-function detectAngularJs() {
+function detectNextJS() {
+  // React SSR
   try {
-    return Object.prototype.hasOwnProperty.call(window, 'angular') || document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]') || document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]');
+    return Object.prototype.hasOwnProperty.call(window, 'next') && Object.prototype.hasOwnProperty.call(window.next, 'version');
+  } catch (err) {
+    return false;
+  }
+}
+function detectVue() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'Vue');
+  } catch (err) {
+    return false;
+  }
+}
+function detectNuxtJS() {
+  // Vue SSR
+  try {
+    return Object.prototype.hasOwnProperty.call(window, '$nuxt') && Object.prototype.hasOwnProperty.call(window.$nuxt, 'nuxt');
   } catch (err) {
     return false;
   }
@@ -58,4 +102,56 @@ function detectAngular() {
   } catch (err) {
     return false;
   }
+}
+function detectAngularUniversal() {
+  // Anguler SSR
+  try {
+    return document.querySelector('[ng-server-context]');
+  } catch (err) {
+    return false;
+  }
+}
+function detectSvelte() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, '__svelte');
+  } catch (err) {
+    return false;
+  }
+}
+function detectSvelteKit() {
+  // Svelte SSR
+  try {
+    return !!Object.keys(window).find(prop => prop.startsWith('__sveltekit'));
+  } catch (err) {
+    return false;
+  }
+}
+function detectPreact() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'preact');
+  } catch (err) {
+    return false;
+  }
+}
+function detectPreactSSR() {
+  // Svelte SSR
+  try {
+    return document.querySelector('script[type="__PREACT_CLI_DATA__"]');
+  } catch (err) {
+    return false;
+  }
+}
+function detectAngularJs() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'angular') || document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]') || document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]');
+  } catch (err) {
+    return false;
+  }
+}
+function detectElectron() {
+  try {
+    return typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent.indexOf('Electron') >= 0;
+  } catch (err) {
+    return false;
+  }
 }

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

@@ -1,19 +1,14 @@
-import { getRuntime, getInfo } from '../../../common/config/config';
+import { getRuntime } from '../../../common/config/config';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants';
-import { drain } from '../../../common/drain/drain';
 import { getFrameworks } from './framework-detection';
-import { getPolyfills } from './polyfill-detection';
 import { isFileProtocol } from '../../../common/url/protocol';
 import { getRules, validateRules } from '../../../common/util/obfuscate';
-import { VERSION } from "../../../common/constants/env.npm";
 import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
-import { isBrowserScope } from '../../../common/constants/runtime';
+import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
-import { stringify } from '../../../common/util/stringify';
-import { endpointMap } from './endpoint-map';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -39,9 +34,8 @@ export class Aggregate extends AggregateBase {
     scheduler.harvest.on('jserrors', () => ({
       body: this.aggregator.take(['cm', 'sm'])
     }));
-    drain(this.agentIdentifier, this.featureName); // regardless if this is blocked or not, drain is needed to unblock other features from harvesting (counteract registerDrain)
+    this.drain();
   }
-
   storeSupportabilityMetrics(name, value) {
     if (this.blocked) return;
     const type = SUPPORTABILITY_METRIC;
@@ -59,9 +53,6 @@ export class Aggregate extends AggregateBase {
     this.aggregator.store(type, name, params, metrics);
   }
   singleChecks() {
-    // report generic info about the agent itself
-    // note the browser agent version
-    this.storeSupportabilityMetrics("Generic/Version/".concat(VERSION, "/Detected"));
     // report loaderType
     const {
       distMethod,
@@ -72,22 +63,27 @@ export class Aggregate extends AggregateBase {
 
     // frameworks on page
     if (isBrowserScope) {
+      this.storeSupportabilityMetrics('Generic/Runtime/Browser/Detected');
+
+      // These SMs are used by the AppExp team
       onDOMContentLoaded(() => {
         getFrameworks().forEach(framework => {
           this.storeSupportabilityMetrics('Framework/' + framework + '/Detected');
         });
       });
+    } else if (isWorkerScope) {
+      this.storeSupportabilityMetrics('Generic/Runtime/Worker/Detected');
+    } else {
+      this.storeSupportabilityMetrics('Generic/Runtime/Unknown/Detected');
     }
-    getPolyfills().forEach(polyfill => {
-      this.storeSupportabilityMetrics('Polyfill/' + polyfill + '/Detected');
-    });
 
-    // file protocol detection
+    // Track if the agent is being loaded using a file protocol such as is the case in some
+    // set-top box applications or Electron applications
     if (isFileProtocol()) {
       this.storeSupportabilityMetrics('Generic/FileProtocol/Detected');
     }
 
-    // obfuscation rules detection
+    // Capture SMs to assess customer engagement with the obfuscation config
     const rules = getRules(this.agentIdentifier);
     if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
     if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
@@ -100,18 +96,17 @@ export class Aggregate extends AggregateBase {
       if (evt.persisted) {
         this.storeSupportabilityMetrics('Generic/BFCache/PageRestored');
       }
-      return;
     });
   }
   unload() {
-    // Page Resources detection for estimations with resources feature work
-    // TODO - these SMs are to be removed when we implement the actual resources feature
     try {
       if (this.resourcesSent) return;
+      this.resourcesSent = true; // make sure this only gets sent once
+
       const agentRuntime = getRuntime(this.agentIdentifier);
-      const info = getInfo(this.agentIdentifier);
-      // make sure this only gets sent once
-      this.resourcesSent = true;
+
+      // Capture SMs around network resources using the performance API to assess
+      // work to split this out from the ST nodes
       // differentiate between internal+external and ajax+non-ajax
       const ajaxResources = ['beacon', 'fetch', 'xmlhttprequest'];
       const internalUrls = ['nr-data.net', 'newrelic.com', 'nr-local.net', 'localhost'];
@@ -130,26 +125,14 @@ export class Aggregate extends AggregateBase {
         }
       });
 
-      // Capture per-agent bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
-      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
-        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpointMap[endpoint], "/BytesSent"), agentRuntime.bytesSent[endpoint]);
-      });
-
-      // Capture per-agent query bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
-      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
-        this.storeSupportabilityMetrics("PageSession/Endpoint/".concat(endpointMap[endpoint], "/QueryBytesSent"), agentRuntime.queryBytesSent[endpoint]);
-      });
-
-      // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).
+      // Capture SMs for session trace if active (`ptid` is set when returned by replay ingest).
+      // Retain these SMs while we are working through the session_replay feature
       if (agentRuntime.ptid) {
         this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()));
       }
 
-      // Capture metrics for size of custom attributes
-      const jsAttributes = stringify(info.jsAttributes);
-      this.storeSupportabilityMetrics('PageSession/Feature/CustomData/Bytes', jsAttributes === '{}' ? 0 : jsAttributes.length);
-
-      // Capture metrics for performance markers and measures
+      // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
+      // data in the agent for use in NR
       if (typeof performance !== 'undefined') {
         const markers = performance.getEntriesByType('mark');
         const measures = performance.getEntriesByType('measure');

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

@@ -1,7 +1,5 @@
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants';
-import { handle } from '../../../common/event-emitter/handle';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { FEATURE_NAME } from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {

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

@@ -10,7 +10,6 @@ import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { cleanURL } from '../../../common/url/clean-url';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
 import { FEATURE_NAME } from '../constants';
-import { drain } from '../../../common/drain/drain';
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 export class Aggregate extends AggregateBase {
@@ -22,8 +21,8 @@ export class Aggregate extends AggregateBase {
     this.eventsPerMinute = 240;
     this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_action.harvestTimeSeconds') || getConfigurationValue(this.agentIdentifier, 'ins.harvestTimeSeconds') || 30;
     this.eventsPerHarvest = this.eventsPerMinute * this.harvestTimeSeconds / 60;
-    this.referrerUrl;
-    this.currentEvents;
+    this.referrerUrl = undefined;
+    this.currentEvents = undefined;
     this.events = [];
     this.att = getInfo(this.agentIdentifier).jsAttributes; // per-agent, aggregators-shared info context
 
@@ -31,24 +30,23 @@ export class Aggregate extends AggregateBase {
     register('api-addPageAction', function () {
       return _this.addPageAction(...arguments);
     }, this.featureName, this.ee);
-    var scheduler = new HarvestScheduler('ins', {
-      onFinished: function () {
-        return _this.onHarvestFinished(...arguments);
+    this.waitForFlags(['ins']).then(_ref => {
+      let [enabled] = _ref;
+      if (enabled) {
+        const scheduler = new HarvestScheduler('ins', {
+          onFinished: function () {
+            return _this.onHarvestFinished(...arguments);
+          }
+        }, this);
+        scheduler.harvest.on('ins', function () {
+          return _this.onHarvestStarted(...arguments);
+        });
+        scheduler.startTimer(this.harvestTimeSeconds, 0);
+      } else {
+        this.blocked = true;
       }
-    }, this);
-    scheduler.harvest.on('ins', function () {
-      return _this.onHarvestStarted(...arguments);
     });
-    this.ee.on("drain-".concat(this.featureName), () => {
-      if (!this.blocked) scheduler.startTimer(this.harvestTimeSeconds, 0);
-    });
-
-    // if rum response determines that customer lacks entitlements for ins endpoint, block it
-    register('block-ins', () => {
-      this.blocked = true;
-      scheduler.stopTimer(true);
-    }, this.featureName, this.ee);
-    drain(this.agentIdentifier, this.featureName);
+    this.drain();
   }
   onHarvestStarted(options) {
     const {

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

@@ -9,7 +9,6 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
-import { drain } from '../../../common/drain/drain';
 import { activateFeatures } from '../../../common/util/feature-flags';
 import { warn } from '../../../common/util/console';
 import { AggregateBase } from '../../utils/aggregate-base';
@@ -147,7 +146,7 @@ export class Aggregate extends AggregateBase {
         }
         try {
           activateFeatures(JSON.parse(responseText), this.agentIdentifier);
-          drain(this.agentIdentifier, this.featureName);
+          this.drain();
         } catch (err) {
           this.ee.abort();
           warn('RUM call failed. Agent shutting down.');

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

@@ -13,10 +13,12 @@ export class Instrument extends InstrumentBase {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME, auto);
     if ((typeof PerformanceNavigationTiming === 'undefined' || isiOS) && typeof PerformanceTiming !== 'undefined') {
       // For majority browser versions in which PNT exists, we can get load timings later from the nav entry (in the aggregate portion). At minimum, PT should exist for main window.
-      // *cli Mar'23 - iOS 15.2 & 15.4 testing in Sauce still fails with onTTFB. Hence, all iOS will fallback to this for now. Unknown if this is similar in nature to iOS_below16 bug.
+      // *cli Mar'23 - iOS 15.2 & 15.4 testing in Sauce still fails with onTTFB. Hence, all iOS will fallback to this for now. Unknown if this is similar in nature to iOSBelow16 bug.
       const agentRuntime = getRuntime(agentIdentifier);
       agentRuntime[CONSTANTS.TTFB] = Math.max(Date.now() - agentRuntime.offset, 0);
-      onDOMContentLoaded(() => agentRuntime[CONSTANTS.FBTDC] = Math.max(now() - agentRuntime[CONSTANTS.TTFB], 0));
+      onDOMContentLoaded(() => {
+        agentRuntime[CONSTANTS.FBTDC] = Math.max(now() - agentRuntime[CONSTANTS.TTFB], 0);
+      });
       onWindowLoad(() => {
         const timeNow = now();
         agentRuntime[CONSTANTS.FBTWL] = Math.max(timeNow - agentRuntime[CONSTANTS.TTFB], 0);

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

@@ -6,7 +6,7 @@
 import { onFCP, onFID, onLCP, onCLS, onINP } from 'web-vitals';
 import { onFirstPaint } from '../first-paint';
 import { onLongTask } from '../long-tasks';
-import { iOS_below16 } from '../../../common/constants/runtime';
+import { iOSBelow16 } from '../../../common/constants/runtime';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { mapOwn } from '../../../common/util/map-own';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -15,7 +15,6 @@ import { cleanURL } from '../../../common/url/clean-url';
 import { handle } from '../../../common/event-emitter/handle';
 import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config';
 import { FEATURE_NAME } from '../constants';
-import { drain } from '../../../common/drain/drain';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
 export class Aggregate extends AggregateBase {
@@ -45,7 +44,7 @@ export class Aggregate extends AggregateBase {
     });
 
     /* First Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
-    if (iOS_below16) {
+    if (iOSBelow16) {
       try {
         if (!pageStartedHidden) {
           // see ios-version.js for detail on this following bug case; tldr: buffered flag doesn't work but getEntriesByType does
@@ -121,7 +120,7 @@ export class Aggregate extends AggregateBase {
       let {
         value
       } = _ref5;
-      return this.cls = value;
+      this.cls = value;
     }, {
       reportAllChanges: true
     });
@@ -170,7 +169,7 @@ export class Aggregate extends AggregateBase {
     this.ee.on("drain-".concat(this.featureName), () => {
       this.scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
     });
-    drain(this.agentIdentifier, this.featureName);
+    this.drain();
   }
 
   // takes an attributes object and appends connection attributes if available
@@ -224,9 +223,9 @@ export class Aggregate extends AggregateBase {
       attrs.cls = this.cls;
     }
     this.timings.push({
-      name: name,
-      value: value,
-      attrs: attrs
+      name,
+      value,
+      attrs
     });
     handle('pvtAdded', [name, value, attrs], undefined, FEATURE_NAMES.sessionTrace, this.ee);
   }

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

@@ -10,7 +10,6 @@
  * functionality is validated and a full user experience is curated.
  */
 
-import { drain } from '../../../common/drain/drain';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { FEATURE_NAME } from '../constants';
@@ -20,6 +19,7 @@ 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';
+import { warn } from '../../../common/util/console';
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8';
@@ -127,7 +127,7 @@ export class Aggregate extends AggregateBase {
         return this.initializeRecording(flagOn, Math.random() < getConfigurationValue(this.agentIdentifier, 'session_replay.errorSampleRate'), Math.random() < getConfigurationValue(this.agentIdentifier, 'session_replay.sampleRate'));
       }).then(() => sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
 
-      drain(this.agentIdentifier, this.featureName);
+      this.drain();
     }
   }
 
@@ -174,11 +174,13 @@ export class Aggregate extends AggregateBase {
       this.scheduler.startTimer(this.harvestTimeSeconds);
     }
     try {
+      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       recorder = (await import( /* webpackChunkName: "recorder" */'rrweb')).record;
     } catch (err) {
       return this.abort();
     }
     try {
+      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       const {
         gzipSync,
         strToU8

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

@@ -8,7 +8,6 @@ import { parseUrl } from '../../../common/url/parse-url';
 import { getConfigurationValue, getRuntime } from '../../../common/config/config';
 import { now } from '../../../common/timing/now';
 import { FEATURE_NAME } from '../constants';
-import { drain } from '../../../common/drain/drain';
 import { HandlerCache } from '../../utils/handler-cache';
 import { MODE, SESSION_EVENTS } from '../../../common/session/session-entity';
 import { getSessionReplayMode } from '../../session_replay/replay-mode';
@@ -57,9 +56,13 @@ export class Aggregate extends AggregateBase {
     this.sentTrace = null;
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
+    /**
+     * Standalone (mode) refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
+     * It has some different behavior vs when used in tandem with replay. */
     this.isStandalone = false;
     const operationalGate = new HandlerCache(); // acts as a controller-intermediary that can enable or disable this feature's collection dynamically
     const sessionEntity = this.agentRuntime.session;
+    this.operationalGate = operationalGate;
 
     /* --- The following section deals with user sessions concept & contains non-trivial control flow. --- */
     const controlTraceOp = traceMode => {
@@ -133,7 +136,9 @@ export class Aggregate extends AggregateBase {
             });
             mostRecentModeKnown = updatedTraceMode;
           });
-          this.ee.on(SESSION_EVENTS.PAUSE, () => mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
+          this.ee.on(SESSION_EVENTS.PAUSE, () => {
+            mostRecentModeKnown = sessionEntity.state.sessionTraceMode;
+          });
           if (!sessionEntity.isNew) {
             // inherit the same mode as existing session's Trace
             if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true;
@@ -205,7 +210,7 @@ export class Aggregate extends AggregateBase {
       }
       return operationalGate.settle(() => _this.processPVT(...args));
     }, this.featureName, this.ee);
-    drain(this.agentIdentifier, this.featureName);
+    this.drain();
   }
   startTracing(startupBuffer) {
     let dontStartHarvestYet = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -243,17 +248,16 @@ export class Aggregate extends AggregateBase {
     }
   }
   #prepareHarvest(options) {
-    /* Standalone refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
-      It has a different behavior on returning a payload for harvest than when used in tandem with either of those concepts. */
     if (this.isStandalone) {
-      if (now() > MAX_TRACE_DURATION) {
-        // been collecting for over the longest duration we should run for, empty trace object so ST has nothing to send
-        this.#scheduler.stopTimer();
-        this.trace = {};
+      if (this.ptid && now() >= MAX_TRACE_DURATION) {
+        // Perform a final harvest once we hit or exceed the max session trace time
+        options.isFinalHarvest = true;
+        this.operationalGate.permanentlyDecide(false);
+        this.#scheduler.stopTimer(true);
+      } else if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
+        // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
         return;
       }
-      // Only harvest when more than some threshold of nodes are pending, after the very first harvest.
-      if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return;
     } else {
       //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
       //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return
@@ -330,8 +334,7 @@ export class Aggregate extends AggregateBase {
     const origin = this.evtOrigin(event.target, target);
     if (event.type in ignoredEvents.global) return true;
     if (!!ignoredEvents[origin] && ignoredEvents[origin].ignoreAll) return true;
-    if (!!ignoredEvents[origin] && event.type in ignoredEvents[origin]) return true;
-    return false;
+    return !!(!!ignoredEvents[origin] && event.type in ignoredEvents[origin]);
   }
   evtName(type) {
     switch (type) {
@@ -441,7 +444,10 @@ export class Aggregate extends AggregateBase {
       // limit the amount of pending data awaiting next harvest
       if (this.isStandalone || this.agentRuntime.session.state.sessionTraceMode !== MODE.ERROR) return;
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
-      if (openedSpace == 0) return;
+      if (openedSpace === 0) return;
+    }
+    if (this.isStandalone && now() >= MAX_TRACE_DURATION) {
+      return;
     }
     if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
     this.nodeCount++;
@@ -461,7 +467,7 @@ export class Aggregate extends AggregateBase {
        * This isn't exact since nodes go through some processing & EE handlers chain, but it's close enough as we still capture nodes whose duration overlaps the lookback window.
        * ASSUMPTION: all 'end' timings stored are relative to timeOrigin (DOMHighResTimeStamp) and not Unix epoch based. */
       let cutoffIdx = nodeList.findIndex(node => cutoffHighResTime <= node.e);
-      if (cutoffIdx == 0) return;else if (cutoffIdx < 0) {
+      if (cutoffIdx === 0) return;else if (cutoffIdx < 0) {
         // whole list falls outside lookback window and is irrelevant
         cutoffIdx = nodeList.length;
         delete this.trace[nameCategory];
@@ -525,7 +531,7 @@ export class Aggregate extends AggregateBase {
     };
     function trivial(node) {
       const limit = 4;
-      if (node && typeof node.e === 'number' && typeof node.s === 'number' && node.e - node.s < limit) return true;else return false;
+      return !!(node && typeof node.e === 'number' && typeof node.s === 'number' && node.e - node.s < limit);
     }
   }
 }

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

@@ -17,7 +17,6 @@ import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { Serializer } from './serializer';
 import { ee } from '../../../common/event-emitter/contextual-ee';
 import * as CONSTANTS from '../constants';
-import { drain } from '../../../common/drain/drain';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
 const {
@@ -135,8 +134,8 @@ export class Aggregate extends AggregateBase {
 
     // register plugins
     var pluginApi = {
-      getCurrentNode: getCurrentNode,
-      setCurrentNode: setCurrentNode
+      getCurrentNode,
+      setCurrentNode
     };
     register('spa-register', function (init) {
       if (typeof init === 'function') {
@@ -201,21 +200,19 @@ export class Aggregate extends AggregateBase {
         // If this event was emitted by an XHR, restore the node ID associated with
         // that XHR.
         setCurrentNode(baseEE.context(eventSource).spaNode);
-      } else if (!state.currentNode) {
+      } else if (!state.currentNode && INTERACTION_EVENTS.indexOf(evName) !== -1) {
         // Otherwise, if no interaction is currently active, create a new node ID,
         // and let the aggregator know that we entered a new event handler callback
         // so that it has a chance to possibly start an interaction.
-        if (INTERACTION_EVENTS.indexOf(evName) !== -1) {
-          var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
+        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
 
-          // Store the interaction as prevInteraction in case it is prematurely discarded
-          state.prevInteraction = ixn;
-          setCurrentNode(ixn.root);
-          if (evName === 'click') {
-            var value = getActionText(ev.target);
-            if (value) {
-              state.currentNode.attrs.custom.actionText = value;
-            }
+        // Store the interaction as prevInteraction in case it is prematurely discarded
+        state.prevInteraction = ixn;
+        setCurrentNode(ixn.root);
+        if (evName === 'click') {
+          var value = getActionText(ev.target);
+          if (value) {
+            state.currentNode.attrs.custom.actionText = value;
           }
         }
       }
@@ -497,7 +494,7 @@ export class Aggregate extends AggregateBase {
     }, this.featureName, promiseEE);
     register(INTERACTION_API + 'get', function (t) {
       var interaction;
-      if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION];else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName != 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION];else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
+      if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION];else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName !== 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION];else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
       if (!state.currentNode) {
         interaction.checkFinish();
         if (state.depth) setCurrentNode(interaction.root);
@@ -665,11 +662,8 @@ export class Aggregate extends AggregateBase {
     }
     function isEnabled() {
       var enabled = getConfigurationValue(agentIdentifier, 'spa.enabled');
-      if (enabled === false) {
-        return false;
-      }
-      return true;
+      return enabled !== false;
     }
-    drain(this.agentIdentifier, this.featureName);
+    this.drain();
   }
 }