@newrelic/browser-agent 1.269.0 → 1.270.0

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

@@ -1,5 +1,3 @@
-import { getConfiguration } from '../../../common/config/init';
-import { getRuntime } from '../../../common/config/runtime';
 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 /*, WATCHABLE_WEB_SOCKET_EVENTS */ } from '../constants';
@@ -9,15 +7,14 @@ import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
-import { deregisterDrain } from '../../../common/drain/drain';
 import { isIFrameWindow } from '../../../common/dom/iframe';
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
         // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
@@ -26,12 +23,12 @@ export class Aggregate extends AggregateBase {
         }, this);
         // this is needed to ensure EoL is "on" and sent
         scheduler.harvest.on('jserrors', () => ({
-          body: this.aggregator.take(['cm', 'sm'])
+          body: this.agentRef.sharedAggregator.take(['cm', 'sm'])
         }));
         this.drain();
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
-        deregisterDrain(this.agentIdentifier, this.featureName);
+        this.deregisterDrain();
       }
     });
 
@@ -47,7 +44,7 @@ export class Aggregate extends AggregateBase {
     const params = {
       name
     };
-    this.aggregator.storeMetric(type, name, params, value);
+    this.agentRef.sharedAggregator.storeMetric(type, name, params, value);
   }
   storeEventMetrics(name, metrics) {
     if (this.blocked) return;
@@ -55,18 +52,18 @@ export class Aggregate extends AggregateBase {
     const params = {
       name
     };
-    this.aggregator.store(type, name, params, metrics);
+    this.agentRef.sharedAggregator.store(type, name, params, metrics);
   }
   singleChecks() {
     // report loaderType
     const {
       distMethod,
       loaderType
-    } = getRuntime(this.agentIdentifier);
+    } = this.agentRef.runtime;
     const {
       proxy,
       privacy
-    } = getConfiguration(this.agentIdentifier);
+    } = this.agentRef.init;
     if (loaderType) this.storeSupportabilityMetrics("Generic/LoaderType/".concat(loaderType, "/Detected"));
     if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
     if (isBrowserScope) {

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

@@ -4,8 +4,8 @@ import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME /*, WATCHABLE_WEB_SOCKET_EVENTS */ } from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     // wrapWebSocket(this.ee)
 
     // WATCHABLE_WEB_SOCKET_EVENTS.forEach((suffix) => {
@@ -14,7 +14,7 @@ export class Instrument extends InstrumentBase {
     //   })
     // })
 
-    this.importAggregator();
+    this.importAggregator(agentRef);
   }
 }
 export const Metrics = Instrument;

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

@@ -1,8 +1,7 @@
 import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
-import { getInfo, isValid } from '../../../common/config/info';
-import { getRuntime } from '../../../common/config/runtime';
+import { isValid } from '../../../common/config/info';
 import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
@@ -17,13 +16,13 @@ import { TimeKeeper } from '../../../common/timing/time-keeper';
 import { applyFnToProps } from '../../../common/util/traverse';
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME);
+  constructor(agentRef) {
+    super(agentRef, CONSTANTS.FEATURE_NAME);
     this.timeToFirstByte = 0;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
-    this.timeKeeper = new TimeKeeper(this.agentIdentifier);
-    if (!isValid(agentIdentifier)) {
+    this.timeKeeper = new TimeKeeper(agentRef.agentIdentifier);
+    if (!isValid(agentRef.agentIdentifier)) {
       this.ee.abort();
       return warn(43);
     }
@@ -45,43 +44,30 @@ export class Aggregate extends AggregateBase {
     }
   }
   sendRum() {
-    const info = getInfo(this.agentIdentifier);
-    const agentRuntime = getRuntime(this.agentIdentifier);
+    const info = this.agentRef.info;
     const harvester = new Harvest(this);
-    if (info.queueTime) this.aggregator.store('measures', 'qt', {
-      value: info.queueTime
-    });
-    if (info.applicationTime) this.aggregator.store('measures', 'ap', {
-      value: info.applicationTime
-    });
+    const measures = {};
+    if (info.queueTime) measures.qt = info.queueTime;
+    if (info.applicationTime) measures.ap = info.applicationTime;
 
     // These 3 values should've been recorded after load and before this func runs. They are part of the minimum required for PageView events to be created.
     // Following PR #428, which demands that all agents send RUM call, these need to be sent even outside of the main window context where PerformanceTiming
     // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
-    this.aggregator.store('measures', 'be', {
-      value: this.timeToFirstByte
-    });
-    this.aggregator.store('measures', 'fe', {
-      value: this.firstByteToWindowLoad
-    });
-    this.aggregator.store('measures', 'dc', {
-      value: this.firstByteToDomContent
-    });
+    measures.be = this.timeToFirstByte;
+    measures.fe = this.firstByteToWindowLoad;
+    measures.dc = this.firstByteToDomContent;
     const queryParameters = {
       tt: info.ttGuid,
       us: info.user,
       ac: info.account,
       pr: info.product,
       af: getActivatedFeaturesFlags(this.agentIdentifier).join(','),
-      ...Object.entries(this.aggregator.get('measures') || {}).reduce((aggregator, [metricName, measure]) => {
-        aggregator[metricName] = measure.params?.value;
-        return aggregator;
-      }, {}),
+      ...measures,
       xx: info.extra,
       ua: info.userAttributes,
       at: info.atts
     };
-    if (agentRuntime.session) queryParameters.fsh = Number(agentRuntime.session.isNew); // "first session harvest" aka RUM request or PageView event of a session
+    if (this.agentRef.runtime.session) queryParameters.fsh = Number(this.agentRef.runtime.session.isNew); // "first session harvest" aka RUM request or PageView event of a session
 
     let body;
     if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
@@ -142,13 +128,13 @@ export class Aggregate extends AggregateBase {
           try {
             this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime, app.nrServerTime);
             if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready');
-            agentRuntime.timeKeeper = this.timeKeeper;
+            this.agentRef.runtime.timeKeeper = this.timeKeeper;
           } catch (error) {
             this.ee.abort();
             warn(17, error);
             return;
           }
-          agentRuntime.appMetadata = app;
+          this.agentRef.runtime.appMetadata = app;
           activateFeatures(flags, this.agentIdentifier);
           this.drain();
         } catch (err) {

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

@@ -2,9 +2,9 @@ import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = CONSTANTS.FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME, auto);
-    this.importAggregator();
+  constructor(agentRef, auto = true) {
+    super(agentRef, CONSTANTS.FEATURE_NAME, auto);
+    this.importAggregator(agentRef);
   }
 }
 export const PageViewEvent = Instrument;

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

@@ -7,8 +7,6 @@ import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { handle } from '../../../common/event-emitter/handle';
-import { getInfo } from '../../../common/config/info';
-import { getConfigurationValue } from '../../../common/config/init';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
@@ -31,13 +29,14 @@ export class Aggregate extends AggregateBase {
   }) => {
     this.addTiming(name, value, attrs);
   };
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
     this.timings = new EventBuffer();
     this.curSessEndRecorded = false;
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee);
-    registerHandler('winPagehide', msTimestamp => this.recordPageUnload(msTimestamp), this.featureName, this.ee);
-    const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.harvestTimeSeconds') || 30;
+    // Add the time of _window pagehide event_ firing to the next PVT harvest == NRDB windowUnload attr:
+    registerHandler('winPagehide', msTimestamp => this.addTiming('unload', msTimestamp, null), this.featureName, this.ee);
+    const harvestTimeSeconds = agentRef.init.page_view_timing.harvestTimeSeconds || 30;
     this.waitForFlags([]).then(() => {
       /* It's important that CWV api, like "onLCP", is called before the **scheduler** is initialized. The reason is because they listen to the same
         on vis change or pagehide events, and we'd want ex. onLCP to record the timing (win the race) before we try to send "final harvest". */
@@ -84,21 +83,6 @@ export class Aggregate extends AggregateBase {
       this.curSessEndRecorded = true;
     }
   }
-
-  /**
-   * Add the time of _window pagehide event_ firing to the next PVT harvest == NRDB windowUnload attr.
-   */
-  recordPageUnload(timestamp) {
-    this.addTiming('unload', timestamp, null);
-    /*
-    Issue: Because window's pageHide commonly fires BEFORE vis change and "final" harvest would happen at the former in this case, we also have to add our vis-change event now or it may not be sent.
-    Affected: Safari < v14.1/.5 ; versions that don't support 'visiilitychange' event
-    Impact: For affected w/o this, NR 'pageHide' attribute may not be sent. For other browsers w/o this, NR 'pageHide' gets fragmented into its own harvest call on page unloading because of dual EoL logic.
-    Mitigation: NR 'unload' and 'pageHide' are both recorded when window pageHide fires, rather than only recording 'unload'.
-    Future: When EoL can become the singular subscribeToVisibilityChange, it's likely endCurrentSession isn't needed here as 'unload'-'pageHide' can be untangled.
-    */
-    this.endCurrentSession(timestamp);
-  }
   addTiming(name, value, attrs) {
     attrs = attrs || {};
     addConnectionAttributes(attrs); // network conditions may differ from the actual for VitalMetrics when they were captured
@@ -126,9 +110,8 @@ export class Aggregate extends AggregateBase {
   }
   appendGlobalCustomAttributes(timing) {
     var timingAttributes = timing.attrs || {};
-    var customAttributes = getInfo(this.agentIdentifier).jsAttributes || {};
     var reservedAttributes = ['size', 'eid', 'cls', 'type', 'fid', 'elTag', 'elUrl', 'net-type', 'net-etype', 'net-rtt', 'net-dlink'];
-    Object.entries(customAttributes || {}).forEach(([key, val]) => {
+    Object.entries(this.agentRef.info.jsAttributes || {}).forEach(([key, val]) => {
       if (reservedAttributes.indexOf(key) < 0) {
         timingAttributes[key] = val;
       }

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

@@ -11,8 +11,8 @@ import { isBrowserScope } from '../../../common/constants/runtime';
 import { now } from '../../../common/timing/now';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     if (!isBrowserScope) return; // CWV is irrelevant outside web context
 
     // While we try to replicate web-vital's visibilitywatcher logic in an effort to defer that library to post-pageload, this isn't perfect and doesn't consider prerendering.
@@ -20,7 +20,7 @@ export class Instrument extends InstrumentBase {
 
     // Window fires its pagehide event (typically on navigation--this occurrence is a *subset* of vis change); don't defer this unless it's guarantee it cannot happen before load(?)
     windowAddEventListener('pagehide', () => handle('winPagehide', [now()], undefined, FEATURE_NAME, this.ee));
-    this.importAggregator();
+    this.importAggregator(agentRef);
   }
 }
 export const PageViewTiming = Instrument;

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

@@ -9,9 +9,6 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { ABORT_REASONS, FEATURE_NAME, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants';
-import { getInfo } from '../../../common/config/info';
-import { getConfigurationValue } from '../../../common/config/init';
-import { getRuntime } from '../../../common/config/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
 import { obj as encodeObj } from '../../../common/url/encode';
@@ -24,7 +21,6 @@ import { RRWEB_VERSION } from "../../../common/constants/env.npm";
 import { MODE, SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants';
 import { stringify } from '../../../common/util/stringify';
 import { stylesheetEvaluator } from '../shared/stylesheet-evaluator';
-import { deregisterDrain } from '../../../common/drain/drain';
 import { now } from '../../../common/timing/now';
 import { buildNRMetaNode } from '../shared/utils';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
@@ -34,10 +30,10 @@ export class Aggregate extends AggregateBase {
   mode = MODE.OFF;
 
   // pass the recorder into the aggregator
-  constructor(agentIdentifier, aggregator, args) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
+  constructor(agentRef, args) {
+    super(agentRef, FEATURE_NAME);
     /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
-    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'session_replay.harvestTimeSeconds') || 60;
+    this.harvestTimeSeconds = agentRef.init.session_replay.harvestTimeSeconds || 60;
     /** Set once the recorder has fully initialized after flag checks and sampling */
     this.initialized = false;
     /** Set once the feature has been "aborted" to prevent other side-effects from continuing */
@@ -71,10 +67,7 @@ export class Aggregate extends AggregateBase {
     this.ee.on(SESSION_EVENTS.RESUME, () => {
       if (!this.recorder) return;
       // if the mode changed on a different tab, it needs to update this instance to match
-      const {
-        session
-      } = getRuntime(this.agentIdentifier);
-      this.mode = session.state.sessionReplayMode;
+      this.mode = agentRef.runtime.session.state.sessionReplayMode;
       if (!this.initialized || this.mode === MODE.OFF) return;
       this.recorder?.startRecording();
     });
@@ -106,11 +99,11 @@ export class Aggregate extends AggregateBase {
       mask_all_inputs,
       inline_images,
       collect_fonts
-    } = getConfigurationValue(this.agentIdentifier, 'session_replay');
+    } = agentRef.init.session_replay;
     this.waitForFlags(['srs', 'sr']).then(([srMode, entitled]) => {
       this.entitled = !!entitled;
       if (!this.entitled) {
-        deregisterDrain(this.agentIdentifier, this.featureName);
+        this.deregisterDrain();
         if (this.recorder?.recording) {
           this.abort(ABORT_REASONS.ENTITLEMENTS);
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/EnabledNotEntitled/Detected'], undefined, FEATURE_NAMES.metrics, this.ee);
@@ -180,7 +173,7 @@ export class Aggregate extends AggregateBase {
     const {
       session,
       timeKeeper
-    } = getRuntime(this.agentIdentifier);
+    } = this.agentRef.runtime;
     this.timeKeeper = timeKeeper;
     if (this.recorder?.parent.trigger === TRIGGERS.API && this.recorder?.recording) {
       this.mode = MODE.FULL;
@@ -296,10 +289,7 @@ export class Aggregate extends AggregateBase {
       return;
     }
     // TODO -- Gracefully handle the buffer for retries.
-    const {
-      session
-    } = getRuntime(this.agentIdentifier);
-    if (!session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
+    if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
       sessionReplaySentFirstChunk: true
     });
     this.recorder.clearBuffer();
@@ -314,9 +304,8 @@ export class Aggregate extends AggregateBase {
   getHarvestContents(recorderEvents) {
     recorderEvents ??= this.recorder.getEvents();
     let events = recorderEvents.events;
-    const agentRuntime = getRuntime(this.agentIdentifier);
-    const info = getInfo(this.agentIdentifier);
-    const endUserId = info.jsAttributes?.['enduser.id'];
+    const agentRuntime = this.agentRef.runtime;
+    const endUserId = this.agentRef.info.jsAttributes?.['enduser.id'];
 
     // do not let the first node be a full snapshot node, since this NEEDS to be preceded by a meta node
     // we will manually inject it if this happens
@@ -344,9 +333,9 @@ export class Aggregate extends AggregateBase {
     const agentMetadata = agentRuntime.appMetadata?.agents?.[0] || {};
     return {
       qs: {
-        browser_monitoring_key: info.licenseKey,
+        browser_monitoring_key: this.agentRef.info.licenseKey,
         type: 'SessionReplay',
-        app_id: info.applicationID,
+        app_id: this.agentRef.info.applicationID,
         protocol_version: '0',
         timestamp: firstTimestamp,
         attributes: encodeObj({
@@ -423,9 +412,6 @@ export class Aggregate extends AggregateBase {
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
   }
   syncWithSessionManager(state = {}) {
-    const {
-      session
-    } = getRuntime(this.agentIdentifier);
-    session.write(state);
+    this.agentRef.runtime.session.write(state);
   }
 }

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

@@ -14,21 +14,23 @@ import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   #mode;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  #agentRef;
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     let session;
     this.replayRunning = false;
+    this.#agentRef = agentRef;
     try {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } catch (err) {}
-    if (hasReplayPrerequisite(agentIdentifier)) {
+    if (hasReplayPrerequisite(agentRef.agentIdentifier)) {
       this.ee.on(SR_EVENT_EMITTER_TYPES.RECORD, () => this.#apiStartOrRestartReplay());
     }
     if (this.#canPreloadRecorder(session)) {
       this.#mode = session?.sessionReplayMode;
       this.#preloadStartRecording();
     } else {
-      this.importAggregator();
+      this.importAggregator(agentRef);
     }
 
     /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
@@ -82,7 +84,7 @@ export class Instrument extends InstrumentBase {
       this.recorder.startRecording();
       this.abortHandler = this.recorder.stopRecording;
     } catch (e) {}
-    this.importAggregator({
+    this.importAggregator(this.#agentRef, {
       recorder: this.recorder,
       errorNoticed: this.errorNoticed
     });

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

@@ -1,13 +1,9 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { getInfo } from '../../../common/config/info';
-import { getConfigurationValue } from '../../../common/config/init';
-import { getRuntime } from '../../../common/config/runtime';
 import { FEATURE_NAME } from '../constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { TraceStorage } from './trace/storage';
 import { obj as encodeObj } from '../../../common/url/encode';
-import { deregisterDrain } from '../../../common/drain/drain';
 import { globalScope } from '../../../common/constants/runtime';
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants';
 import { applyFnToProps } from '../../../common/util/traverse';
@@ -17,14 +13,12 @@ const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track
 const QUERY_PARAM_PADDING = 5000;
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
-    this.agentRuntime = getRuntime(agentIdentifier);
-    this.agentInfo = getInfo(agentIdentifier);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
 
     /** A buffer to hold on to harvested traces in the case that a retry must be made later */
     this.sentTrace = null;
-    this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 30;
+    this.harvestTimeSeconds = agentRef.init.session_trace.harvestTimeSeconds || 30;
     /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
     this.entitled = undefined;
     /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
@@ -40,12 +34,12 @@ export class Aggregate extends AggregateBase {
   /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
   initialize(stMode, stEntitled, ignoreSession) {
     this.entitled ??= stEntitled;
-    if (this.blocked || !this.entitled) return deregisterDrain(this.agentIdentifier, this.featureName);
+    if (this.blocked || !this.entitled) return this.deregisterDrain();
     if (!this.initialized) {
       this.initialized = true;
       /** Store session identifiers at initialization time to be cross-checked later at harvest time for session changes that are subject to race conditions */
-      this.ptid = this.agentRuntime.ptid;
-      this.sessionId = this.agentRuntime.session?.state.value;
+      this.ptid = this.agentRef.runtime.ptid;
+      this.sessionId = this.agentRef.runtime.session?.state.value;
       // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
       this.ee.on(SESSION_EVENTS.RESET, () => {
         if (this.blocked) return;
@@ -69,12 +63,12 @@ export class Aggregate extends AggregateBase {
 
     /** ST/SR sampling flow in BCS - https://drive.google.com/file/d/19hwt2oft-8Hh4RrjpLqEXfpP_9wYBLcq/view?usp=sharing */
     /** ST will run in the mode provided by BCS if the session IS NEW.  If not... it will use the state of the session entity to determine what mode to run in */
-    if (!this.agentRuntime.session.isNew && !ignoreSession) this.mode = this.agentRuntime.session.state.sessionTraceMode;else this.mode = stMode;
+    if (!this.agentRef.runtime.session.isNew && !ignoreSession) this.mode = this.agentRef.runtime.session.state.sessionTraceMode;else this.mode = stMode;
 
     /** If the mode is off, we do not want to hold up draining for other features, so we deregister the feature for now.
      * If it drains later (due to a mode change), data and handlers will instantly drain instead of waiting for the registry. */
-    if (this.mode === MODE.OFF) return deregisterDrain(this.agentIdentifier, this.featureName);
-    this.timeKeeper ??= this.agentRuntime.timeKeeper;
+    if (this.mode === MODE.OFF) return this.deregisterDrain();
+    this.timeKeeper ??= this.agentRef.runtime.timeKeeper;
     this.scheduler = new HarvestScheduler('browser/blobs', {
       onFinished: this.onHarvestFinished.bind(this),
       retryDelay: this.harvestTimeSeconds,
@@ -98,7 +92,7 @@ export class Aggregate extends AggregateBase {
         if (this.mode === MODE.ERROR) this.switchToFull();
       }, this.featureName, this.ee);
     }
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     this.drain();
@@ -116,7 +110,7 @@ export class Aggregate extends AggregateBase {
     this.traceStorage.prevStoredEvents.clear(); // release references to past events for GC
     if (!this.timeKeeper?.ready) return; // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
     if (this.blocked || this.mode !== MODE.FULL || this.traceStorage.nodeCount === 0) return;
-    if (this.sessionId !== this.agentRuntime.session?.state.value || this.ptid !== this.agentRuntime.ptid) return this.abort(3); // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
+    if (this.sessionId !== this.agentRef.runtime.session?.state.value || this.ptid !== this.agentRef.runtime.ptid) return this.abort(3); // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
     /** Get the ST nodes from the traceStorage buffer.  This also returns helpful metadata about the payload. */
     const {
       stns,
@@ -127,12 +121,12 @@ export class Aggregate extends AggregateBase {
     if (options.retry) {
       this.sentTrace = stns;
     }
-    const firstSessionHarvest = !this.agentRuntime.session.state.traceHarvestStarted;
-    if (firstSessionHarvest) this.agentRuntime.session.write({
+    const firstSessionHarvest = !this.agentRef.runtime.session.state.traceHarvestStarted;
+    if (firstSessionHarvest) this.agentRef.runtime.session.write({
       traceHarvestStarted: true
     });
-    const hasReplay = this.agentRuntime.session?.state.sessionReplayMode === 1;
-    const endUserId = this.agentInfo?.jsAttributes?.['enduser.id'];
+    const hasReplay = this.agentRef.runtime.session?.state.sessionReplayMode === 1;
+    const endUserId = this.agentRef.info?.jsAttributes?.['enduser.id'];
     this.everHarvested = true;
 
     /** The blob consumer expects the following and will reject if not supplied:
@@ -144,19 +138,19 @@ export class Aggregate extends AggregateBase {
      *
      * For data that does not fit the schema of the above, it should be url-encoded and placed into `attributes`
      */
-    const agentMetadata = this.agentRuntime.appMetadata?.agents?.[0] || {};
+    const agentMetadata = this.agentRef.runtime.appMetadata?.agents?.[0] || {};
     return {
       qs: {
-        browser_monitoring_key: this.agentInfo.licenseKey,
+        browser_monitoring_key: this.agentRef.info.licenseKey,
         type: 'BrowserSessionChunk',
-        app_id: this.agentInfo.applicationID,
+        app_id: this.agentRef.info.applicationID,
         protocol_version: '0',
         timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
         attributes: encodeObj({
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
           }),
-          harvestId: "".concat(this.agentRuntime.session?.state.value, "_").concat(this.agentRuntime.ptid, "_").concat(this.agentRuntime.harvestCount),
+          harvestId: "".concat(this.agentRef.runtime.session?.state.value, "_").concat(this.agentRef.runtime.ptid, "_").concat(this.agentRef.runtime.harvestCount),
           // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
           // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
           // trace payload metadata
@@ -165,7 +159,7 @@ export class Aggregate extends AggregateBase {
           'trace.nodes': stns.length,
           'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
           // other payload metadata
-          agentVersion: this.agentRuntime.version,
+          agentVersion: this.agentRef.runtime.version,
           ...(firstSessionHarvest && {
             firstSessionHarvest
           }),
@@ -204,7 +198,7 @@ export class Aggregate extends AggregateBase {
     if (this.mode === MODE.FULL || !this.entitled || this.blocked) return;
     const prevMode = this.mode;
     this.mode = MODE.FULL;
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     if (prevMode === MODE.OFF || !this.initialized) return this.initialize(this.mode, this.entitled);
@@ -218,7 +212,7 @@ export class Aggregate extends AggregateBase {
   abort(reason) {
     this.blocked = true;
     this.mode = MODE.OFF;
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     this.scheduler?.stopTimer();

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

@@ -8,7 +8,6 @@ import { wrapEvents } from '../../../common/wrap/wrap-events';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { deregisterDrain } from '../../../common/drain/drain';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
 import { now } from '../../../common/timing/now';
 const {
@@ -23,11 +22,11 @@ const {
 } = CONSTANTS;
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     const canTrackSession = canEnableSessionTracking(this.agentIdentifier);
     if (!canTrackSession) {
-      deregisterDrain(this.agentIdentifier, this.featureName);
+      this.deregisterDrain();
       return;
     }
     const thisInstrumentEE = this.ee;
@@ -63,7 +62,7 @@ export class Instrument extends InstrumentBase {
     } catch (e) {
       // Per NEWRELIC-8525, we don't have a fallback for capturing resources for older versions that don't support PO at this time.
     }
-    this.importAggregator({
+    this.importAggregator(agentRef, {
       resourceObserver: observer
     });
   }