@newrelic/browser-agent 1.269.0 → 1.270.1

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

@@ -1,6 +1,3 @@
-import { getInfo } from '../../../common/config/info';
-import { getConfigurationValue } from '../../../common/config/init';
-import { getRuntime } from '../../../common/config/runtime';
 import { handle } from '../../../common/event-emitter/handle';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -16,16 +13,12 @@ import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 import { EventBuffer } from '../../utils/event-buffer';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  #agentRuntime;
-  #agentInfo;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
 
     /** held logs before sending */
     this.bufferedLogs = new EventBuffer();
-    this.#agentRuntime = getRuntime(this.agentIdentifier);
-    this.#agentInfo = getInfo(this.agentIdentifier);
-    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'logging.harvestTimeSeconds');
+    this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds;
     this.waitForFlags([]).then(() => {
       this.scheduler = new HarvestScheduler('browser/logs', {
         onFinished: this.onHarvestFinished.bind(this),
@@ -60,7 +53,7 @@ export class Aggregate extends AggregateBase {
       return;
     }
     if (typeof message !== 'string' || !message) return warn(32);
-    const log = new Log(Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
+    const log = new Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
     const logBytes = log.message.length + stringify(log.attributes).length + log.level.length + 10; // timestamp == 10 chars
 
     if (!this.bufferedLogs.canMerge(logBytes)) {
@@ -81,34 +74,34 @@ export class Aggregate extends AggregateBase {
     /** These attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB */
     const unbilledAttributes = {
       'instrumentation.provider': 'browser',
-      'instrumentation.version': this.#agentRuntime.version,
-      'instrumentation.name': this.#agentRuntime.loaderType
+      'instrumentation.version': this.agentRef.runtime.version,
+      'instrumentation.name': this.agentRef.runtime.loaderType
     };
     /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
     const payload = {
       qs: {
-        browser_monitoring_key: this.#agentInfo.licenseKey
+        browser_monitoring_key: this.agentRef.info.licenseKey
       },
       body: [{
         common: {
           /** Attributes in the `common` section are added to `all` logs generated in the payload */
           attributes: {
-            'entity.guid': this.#agentRuntime.appMetadata?.agents?.[0]?.entityGuid,
+            'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid,
             // browser entity guid as provided from RUM response
-            session: this.#agentRuntime?.session?.state.value || '0',
+            session: this.agentRef.runtime.session?.state.value || '0',
             // The session ID that we generate and keep across page loads
-            hasReplay: this.#agentRuntime?.session?.state.sessionReplayMode === 1,
+            hasReplay: this.agentRef.runtime.session?.state.sessionReplayMode === 1,
             // True if a session replay recording is running
-            hasTrace: this.#agentRuntime?.session?.state.sessionTraceMode === 1,
+            hasTrace: this.agentRef.runtime.session?.state.sessionTraceMode === 1,
             // True if a session trace recording is running
-            ptid: this.#agentRuntime.ptid,
+            ptid: this.agentRef.runtime.ptid,
             // page trace id
-            appId: this.#agentInfo.applicationID,
+            appId: this.agentRef.info.applicationID,
             // Application ID from info object,
-            standalone: Boolean(this.#agentInfo.sa),
+            standalone: Boolean(this.agentRef.info.sa),
             // copy paste (true) vs APM (false)
-            agentVersion: this.#agentRuntime.version,
-            // browser agent version,
+            agentVersion: this.agentRef.runtime.version,
+            // browser agent version
             ...unbilledAttributes
           }
         },

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

@@ -3,8 +3,8 @@ import { FEATURE_NAME } from '../constants';
 import { bufferLog } from '../shared/utils';
 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 instanceEE = this.ee;
     /** emitted by wrap-logger function */
     this.ee.on('wrap-logger-end', function handleLog([message]) {
@@ -14,7 +14,7 @@ export class Instrument extends InstrumentBase {
       } = this;
       bufferLog(instanceEE, message, customAttributes, level);
     });
-    this.importAggregator();
+    this.importAggregator(agentRef);
   }
 }
 export const Logging = Instrument;

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
     });