@newrelic/browser-agent 1.242.0 → 1.243.0

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

@@ -15,18 +15,43 @@ import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { FEATURE_NAME } from '../constants';
 import { stringify } from '../../../common/util/stringify';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
-import { SESSION_EVENTS, MODE } from '../../../common/session/session-entity';
+import { SESSION_EVENTS, MODE, SESSION_EVENT_TYPES } 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';
 import { globalScope } from '../../../common/constants/runtime';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8';
 export const AVG_COMPRESSION = 0.12;
+export const RRWEB_EVENT_TYPES = {
+  DomContentLoaded: 0,
+  Load: 1,
+  FullSnapshot: 2,
+  IncrementalSnapshot: 3,
+  Meta: 4,
+  Custom: 5
+};
+const ABORT_REASONS = {
+  RESET: {
+    message: 'Session was reset',
+    sm: 'Reset'
+  },
+  IMPORT: {
+    message: 'Recorder failed to import',
+    sm: 'Import'
+  },
+  TOO_MANY: {
+    message: '429: Too Many Requests',
+    sm: 'Too-Many'
+  },
+  TOO_BIG: {
+    message: 'Payload was too large',
+    sm: 'Too-Big'
+  }
+};
 let recorder, gzipper, u8;
 
 /** Vortex caps payload sizes at 1MB */
@@ -60,8 +85,6 @@ export class Aggregate extends AggregateBase {
     /** can shut off efforts to compress the data */
     this.shouldCompress = true;
 
-    /** Payload metadata -- Should indicate that the payload being sent is the first of a session */
-    this.isFirstChunk = false;
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen
      * -- When the recording library begins recording, it starts by taking a DOM snapshot
      * -- When visibility changes from "hidden" -> "visible", it must capture a full snapshot for the replay to work correctly across tabs
@@ -75,16 +98,7 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs.
      * cycle timestamps are used as fallbacks if event timestamps cannot be used
      */
-    this.timestamp = {
-      event: {
-        first: undefined,
-        last: undefined
-      },
-      cycle: {
-        first: undefined,
-        last: undefined
-      }
-    };
+    this.cycleTimestamp = undefined;
 
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0;
@@ -98,7 +112,7 @@ export class Aggregate extends AggregateBase {
     if (shouldSetup) {
       // 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, () => {
-        this.abort('Session Reset');
+        this.abort(ABORT_REASONS.RESET);
       });
 
       // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
@@ -107,9 +121,19 @@ export class Aggregate extends AggregateBase {
       });
       // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
       this.ee.on(SESSION_EVENTS.RESUME, () => {
+        // 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.sessionReplay;
         if (!this.initialized || this.mode === MODE.OFF) return;
         this.startRecording();
       });
+      this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+        if (!this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
+        if (this.mode !== MODE.OFF && data.sessionReplay === MODE.OFF) this.abort('Session Entity was set to OFF on another tab');
+        this.mode = data.sessionReplay;
+      });
 
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
       this.scheduler = new HarvestScheduler('browser/blobs', {
@@ -125,7 +149,7 @@ export class Aggregate extends AggregateBase {
         this.hasError = true;
         this.errorNoticed = true;
         // run once
-        if (this.mode === MODE.ERROR) {
+        if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
           this.mode = MODE.FULL;
           // if the error was noticed AFTER the recorder was already imported....
           if (recorder && this.initialized) {
@@ -185,7 +209,7 @@ export class Aggregate extends AggregateBase {
       // 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('Recorder failed to import');
+      return this.abort(ABORT_REASONS.IMPORT);
     }
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
@@ -208,7 +232,6 @@ export class Aggregate extends AggregateBase {
       this.shouldCompress = false;
     }
     this.startRecording();
-    this.isFirstChunk = !!session.isNew;
     this.syncWithSessionManager({
       sessionReplay: this.mode
     });
@@ -223,14 +246,39 @@ export class Aggregate extends AggregateBase {
       this.scheduler.opts.gzip = false;
     }
     // TODO -- Gracefully handle the buffer for retries.
+    const {
+      session
+    } = getRuntime(this.agentIdentifier);
+    if (!session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
+      sessionReplaySentFirstChunk: true
+    });
     this.clearBuffer();
     return [payload];
   }
   getHarvestContents() {
     const agentRuntime = getRuntime(this.agentIdentifier);
     const info = getInfo(this.agentIdentifier);
-    const firstTimestamp = this.timestamp.event.first || this.timestamp.cycle.first;
-    const lastTimestamp = this.timestamp.event.last || this.timestamp.cycle.last;
+
+    // do not let the last node be a meta node, since this NEEDS to precede a snapshot
+    // we will manually inject it later if we find a payload that is missing a meta node
+    const payloadEndsWithMeta = this.events[this.events.length - 1]?.type === RRWEB_EVENT_TYPES.Meta;
+    if (payloadEndsWithMeta) {
+      this.lastMeta = this.events[this.events.length - 1];
+      this.events = this.events.slice(0, this.events.length - 1);
+      this.hasMeta = !!this.events.find(x => x.type === RRWEB_EVENT_TYPES.Meta);
+    }
+
+    // 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
+    const payloadStartsWithFullSnapshot = this.events[0]?.type === RRWEB_EVENT_TYPES.FullSnapshot;
+    if (payloadStartsWithFullSnapshot) {
+      this.hasMeta = true;
+      this.events.unshift(this.lastMeta);
+    }
+    const firstEventTimestamp = this.events[0]?.timestamp;
+    const lastEventTimestamp = this.events[this.events.length - 1]?.timestamp;
+    const firstTimestamp = firstEventTimestamp || this.cycleTimestamp;
+    const lastTimestamp = lastEventTimestamp || getRuntime(this.agentIdentifier).offset + globalScope.performance.now();
     return {
       qs: {
         browser_monitoring_key: info.licenseKey,
@@ -244,12 +292,13 @@ export class Aggregate extends AggregateBase {
           'replay.firstTimestamp': firstTimestamp,
           'replay.lastTimestamp': lastTimestamp,
           'replay.durationMs': lastTimestamp - firstTimestamp,
+          'replay.nodes': this.events.length,
           agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
           hasMeta: this.hasMeta,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
-          isFirstChunk: this.isFirstChunk,
+          isFirstChunk: agentRuntime.session.state.sessionReplaySentFirstChunk === false,
           decompressedBytes: this.payloadBytesEstimation,
           'nr.rrweb.version': RRWEB_VERSION
         }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
@@ -261,7 +310,7 @@ export class Aggregate extends AggregateBase {
   onHarvestFinished(result) {
     // The mutual decision for now is to stop recording and clear buffers if ingest is experiencing 429 rate limiting
     if (result.status === 429) {
-      this.abort('429: Too many requests');
+      this.abort(ABORT_REASONS.TOO_MANY);
     }
     if (this.blocked) this.scheduler.stopTimer(true);
   }
@@ -269,7 +318,6 @@ export class Aggregate extends AggregateBase {
   /** Clears the buffer (this.events), and resets all payload metadata properties */
   clearBuffer() {
     this.events = [];
-    this.isFirstChunk = false;
     this.hasSnapshot = false;
     this.hasMeta = false;
     this.hasError = false;
@@ -281,7 +329,7 @@ export class Aggregate extends AggregateBase {
   startRecording() {
     if (!recorder) {
       warn('Recording library was never imported');
-      return this.abort('Recorder was never imported');
+      return this.abort(ABORT_REASONS.IMPORT);
     }
     this.clearTimestamps();
     // set the fallbacks as early as possible
@@ -317,7 +365,7 @@ export class Aggregate extends AggregateBase {
 
   /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
   store(event, isCheckout) {
-    this.setTimestamps(event);
+    this.setTimestamps();
     if (this.blocked) return;
     const eventBytes = stringify(event).length;
     /** The estimated size of the payload after compression */
@@ -325,8 +373,7 @@ export class Aggregate extends AggregateBase {
     // Vortex will block payloads at a certain size, we might as well not send.
     if (payloadSize > MAX_PAYLOAD_SIZE) {
       this.clearBuffer();
-      this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Too-Big/Seen'], undefined, FEATURE_NAMES.metrics, this.ee);
-      return this.abort('Payload too big');
+      return this.abort(ABORT_REASONS.TOO_BIG);
     }
     // Checkout events are flags by the recording lib that indicate a fullsnapshot was taken every n ms. These are important
     // to help reconstruct the replay later and must be included.  While waiting and buffering for errors to come through,
@@ -337,19 +384,13 @@ export class Aggregate extends AggregateBase {
     }
 
     // meta event
-    if (event.type === 4) {
+    if (event.type === RRWEB_EVENT_TYPES.Meta) {
       this.hasMeta = true;
       this.lastMeta = event;
     }
     // snapshot event
-    if (event.type === 2) {
+    if (event.type === RRWEB_EVENT_TYPES.FullSnapshot) {
       this.hasSnapshot = true;
-      // small chance that the meta event got separated from its matching snapshot across payload harvests
-      // it needs to precede the snapshot, so shove it in first.
-      if (!this.hasMeta) {
-        this.events.push(this.lastMeta);
-        this.hasMeta = true;
-      }
     }
     this.events.push(event);
     this.payloadBytesEstimation += eventBytes;
@@ -367,26 +408,12 @@ export class Aggregate extends AggregateBase {
     if (!recorder) return;
     recorder.takeFullSnapshot();
   }
-  setTimestamps(event) {
+  setTimestamps() {
     // fallbacks if timestamps cannot be derived from rrweb events
-    this.timestamp.cycle.last = getRuntime(this.agentIdentifier).offset + globalScope.performance.now();
-    if (!this.timestamp.cycle.first) this.timestamp.cycle.first = this.timestamp.cycle.last;
-    // timestamps based on rrweb events
-    if (!event || !event.timestamp) return;
-    if (!this.timestamp.event.first) this.timestamp.event.first = event.timestamp;
-    this.timestamp.event.last = event.timestamp;
+    if (!this.cycleTimestamp) this.cycleTimestamp = getRuntime(this.agentIdentifier).offset + globalScope.performance.now();
   }
   clearTimestamps() {
-    this.timestamp = {
-      event: {
-        first: undefined,
-        last: undefined
-      },
-      cycle: {
-        first: undefined,
-        last: undefined
-      }
-    };
+    this.cycleTimestamp = undefined;
   }
 
   /** Estimate the payload size */
@@ -397,8 +424,10 @@ export class Aggregate extends AggregateBase {
   }
 
   /** Abort the feature, once aborted it will not resume */
-  abort(reason) {
-    warn("SR aborted -- ".concat(reason));
+  abort() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    warn("SR aborted -- ".concat(reason.message));
+    this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ["SessionReplay/Abort/".concat(ABORT_REASONS[reason.sm])]);
     this.blocked = true;
     this.mode = MODE.OFF;
     this.stopRecording();

package/dist/esm/features/utils/feature-base.js

@@ -1,4 +1,3 @@
-import { getRuntime } from '../../common/config/config';
 import { ee } from '../../common/event-emitter/contextual-ee';
 export class FeatureBase {
   constructor(agentIdentifier, aggregator, featureName) {
@@ -7,7 +6,7 @@ export class FeatureBase {
     /** @type {Aggregator} */
     this.aggregator = aggregator;
     /** @type {ContextualEE} */
-    this.ee = ee.get(agentIdentifier, getRuntime(this.agentIdentifier).isolatedBacklog);
+    this.ee = ee.get(agentIdentifier);
     /** @type {string} */
     this.featureName = featureName;
     /**

package/dist/esm/loaders/api/api.js

@@ -17,7 +17,7 @@ export const CUSTOM_ATTR_GROUP = 'CUSTOM/'; // the subgroup items should be stor
 
 export function setTopLevelCallers() {
   const nr = gosCDN();
-  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'inlineHit', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start'];
+  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start'];
   funcs.forEach(f => {
     nr[f] = function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -44,7 +44,7 @@ export function setAPI(agentIdentifier, forceDrain) {
   const apiInterface = {};
   var instanceEE = ee.get(agentIdentifier);
   var tracerEE = instanceEE.get('tracer');
-  var asyncApiFns = ['setErrorHandler', 'finished', 'addToTrace', 'inlineHit', 'addRelease'];
+  var asyncApiFns = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];
   var prefix = 'api-';
   var spaPrefix = prefix + 'ixn-';
 

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

@@ -1,20 +1,16 @@
 import { FEATURE_NAMES } from '../features/features';
-import { getConfiguration, getInfo, getRuntime } from '../../common/config/config';
+import { getRuntime } from '../../common/config/config';
 import { ee } from '../../common/event-emitter/contextual-ee';
 import { handle } from '../../common/event-emitter/handle';
 import { registerHandler } from '../../common/event-emitter/register-handler';
 import { single } from '../../common/util/invoke';
-import * as submitData from '../../common/util/submit-data';
-import { isBrowserScope } from '../../common/constants/runtime';
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants';
 export function setAPI(agentIdentifier) {
   var instanceEE = ee.get(agentIdentifier);
-  var cycle = 0;
   var api = {
     finished: single(finished),
     setErrorHandler,
     addToTrace,
-    inlineHit,
     addRelease
   };
 
@@ -50,37 +46,6 @@ export function setAPI(agentIdentifier) {
     };
     handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, instanceEE);
   }
-
-  // NREUM.inlineHit(requestName, queueTime, appTime, totalBackEndTime, domTime, frontEndTime)
-  //
-  // requestName - the 'web page' name or service name
-  // queueTime - the amount of time spent in the app tier queue
-  // appTime - the amount of time spent in the application code
-  // totalBackEndTime - the total roundtrip time of the remote service call
-  // domTime - the time spent processing the result of the service call (or user defined)
-  // frontEndTime - the time spent rendering the result of the service call (or user defined)
-  function inlineHit(t, requestName, queueTime, appTime, totalBackEndTime, domTime, frontEndTime) {
-    if (!isBrowserScope) return;
-    requestName = window.encodeURIComponent(requestName);
-    cycle += 1;
-    const agentInfo = getInfo(agentIdentifier);
-    if (!agentInfo.beacon) return;
-    const agentInit = getConfiguration(agentIdentifier);
-    const scheme = agentInit.ssl === false ? 'http' : 'https';
-    const beacon = agentInit.proxy.beacon || agentInfo.beacon;
-    let url = "".concat(scheme, "://").concat(beacon, "/1/").concat(agentInfo.licenseKey);
-    url += '?a=' + agentInfo.applicationID + '&';
-    url += 't=' + requestName + '&';
-    url += 'qt=' + ~~queueTime + '&';
-    url += 'ap=' + ~~appTime + '&';
-    url += 'be=' + ~~totalBackEndTime + '&';
-    url += 'dc=' + ~~domTime + '&';
-    url += 'fe=' + ~~frontEndTime + '&';
-    url += 'c=' + cycle;
-    submitData.xhr({
-      url
-    });
-  }
   function setErrorHandler(t, handler) {
     getRuntime(agentIdentifier).onerror = handler;
   }

package/dist/esm/loaders/configure/configure.js

@@ -41,7 +41,7 @@ export function configure(agentIdentifier) {
   if (!alreadySetOnce) {
     alreadySetOnce = true;
     if (updatedInit.proxy.assets) {
-      redefinePublicPath(updatedInit.proxy.assets + '/'); // much like the info.beacon & init.proxy.beacon, this input should not end in a slash, but one is needed for webpack concat
+      redefinePublicPath(updatedInit.proxy.assets);
       internalTrafficList.push(updatedInit.proxy.assets);
     }
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon);

package/dist/esm/loaders/configure/public-path.js

@@ -1,6 +1,9 @@
 // Set the default CDN or remote for fetching the assets; NPM shouldn't change this var.
 
-export const redefinePublicPath = url => {
-  // There's no URL validation here, so caller should check arg if need be.
-  __webpack_public_path__ = url; // eslint-disable-line
+export const redefinePublicPath = urlString => {
+  const isOrigin = urlString.startsWith('http');
+  // Input is not expected to end in a slash, but webpack concats as-is, so one is inserted.
+  urlString += '/';
+  // If there's no existing HTTP scheme, the secure protocol is prepended by default.
+  __webpack_public_path__ = isOrigin ? urlString : 'https://' + urlString; // eslint-disable-line
 };

package/dist/types/common/session/session-entity.d.ts

@@ -7,6 +7,11 @@ export namespace SESSION_EVENTS {
     const PAUSE: string;
     const RESET: string;
     const RESUME: string;
+    const UPDATE: string;
+}
+export namespace SESSION_EVENT_TYPES {
+    const SAME_TAB: string;
+    const CROSS_TAB: string;
 }
 export class SessionEntity {
     /**

package/dist/types/common/session/session-entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":";;;;;;;;;;AAoCA;IACE;;;;;OAKG;IACH,uBAgBC;IAVC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAKnC;;;;aAsEC;IA/DC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;IAOV,2BAA6C;IAM3E,iCAAuB;IAIzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAiBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAYC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA1RqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AA4CA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAsEC;IA/DC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;IAOV,2BAA6C;IAM3E,iCAAuB;IAIzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAYC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA7SqB,gBAAgB;iCAGL,4BAA4B"}

package/dist/types/features/session_replay/aggregate/index.d.ts

@@ -1,5 +1,13 @@
 export const RRWEB_VERSION: "2.0.0-alpha.8";
 export const AVG_COMPRESSION: 0.12;
+export namespace RRWEB_EVENT_TYPES {
+    const DomContentLoaded: number;
+    const Load: number;
+    const FullSnapshot: number;
+    const IncrementalSnapshot: number;
+    const Meta: number;
+    const Custom: number;
+}
 /** Vortex caps payload sizes at 1MB */
 export const MAX_PAYLOAD_SIZE: 1000000;
 /** Unloading caps around 64kb */
@@ -21,8 +29,6 @@ export class Aggregate extends AggregateBase {
     recording: boolean;
     /** can shut off efforts to compress the data */
     shouldCompress: boolean;
-    /** Payload metadata -- Should indicate that the payload being sent is the first of a session */
-    isFirstChunk: boolean;
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen
      * -- When the recording library begins recording, it starts by taking a DOM snapshot
      * -- When visibility changes from "hidden" -> "visible", it must capture a full snapshot for the replay to work correctly across tabs
@@ -35,16 +41,7 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs.
      * cycle timestamps are used as fallbacks if event timestamps cannot be used
      */
-    timestamp: {
-        event: {
-            first: undefined;
-            last: undefined;
-        };
-        cycle: {
-            first: undefined;
-            last: undefined;
-        };
-    };
+    cycleTimestamp: any;
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     payloadBytesEstimation: number;
     /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
@@ -89,12 +86,12 @@ export class Aggregate extends AggregateBase {
     store(event: any, isCheckout: any): void;
     /** force the recording lib to take a full DOM snapshot.  This needs to occur in certain cases, like visibility changes */
     takeFullSnapshot(): void;
-    setTimestamps(event: any): void;
+    setTimestamps(): void;
     clearTimestamps(): void;
     /** Estimate the payload size */
     getPayloadSize(newBytes?: number): any;
     /** Abort the feature, once aborted it will not resume */
-    abort(reason: any): void;
+    abort(reason?: {}): void;
     /** Extensive research has yielded about an 88% compression factor on these payloads.
      * This is an estimation using that factor as to not cause performance issues while evaluating
      * https://staging.onenr.io/037jbJWxbjy

package/dist/types/features/session_replay/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AA2BA,4CAA4C;AAE5C,mCAAmC;AAInC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AAIvC;IACE,2BAAiC;IACjC,mDAmGC;IAjGC,iHAAiH;IACjH,cAAgB;IAChB,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IACxB,mEAAmE;IACnE,sBAAyB;IACzB,6GAA6G;IAC7G,aAAoB;IAGpB,iEAAiE;IACjE,mBAAsB;IACtB,gDAAgD;IAChD,wBAA0B;IAE1B,gGAAgG;IAChG,sBAAyB;IACzB;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IAErB;;OAEG;IACH;;;;;;;;;MAA+G;IAE/G,qGAAqG;IACrG,+BAA+B;IAE/B,kIAAkI;IAClI,cAAyB;IAOzB,uIAAuI;IACvI,0BAAyE;IAiBvE,wCAKQ;IA+BZ;;;;;;OAMG;IACH,kCALW,OAAO,eACP,OAAO,cACP,OAAO,GACL,IAAI,CAyDhB;IAED;;;;;;;;;oBAaC;IAED;;;;;;;;;MA4BC;IAED,qCAOC;IAED,kFAAkF;IAClF,oBAQC;IAED,qDAAqD;IACrD,uBA4BC;IAED,yHAAyH;IACzH,yCA6CC;IAED,0HAA0H;IAC1H,yBAGC;IAED,gCAQC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED,yDAAyD;IACzD,yBAQC;IAED;;;SAGK;IACL,oCAGC;IAED,yCAGC;CACF;8BA/X6B,4BAA4B;iCALzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AA0BA,4CAA4C;AAE5C,mCAAmC;;;;;;;;;AAgCnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AAIvC;IACE,2BAAiC;IACjC,mDA2GC;IAzGC,iHAAiH;IACjH,cAAgB;IAChB,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IACxB,mEAAmE;IACnE,sBAAyB;IACzB,6GAA6G;IAC7G,aAAoB;IAGpB,iEAAiE;IACjE,mBAAsB;IACtB,gDAAgD;IAChD,wBAA0B;IAE1B;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IAErB;;OAEG;IACH,oBAA+B;IAE/B,qGAAqG;IACrG,+BAA+B;IAE/B,kIAAkI;IAClI,cAAyB;IAOzB,uIAAuI;IACvI,0BAAyE;IA0BvE,wCAKQ;IAgCZ;;;;;;OAMG;IACH,kCALW,OAAO,eACP,OAAO,cACP,OAAO,GACL,IAAI,CAuDhB;IAED;;;;;;;;;oBAeC;IAED;;;;;;;;;MAiDC;IAED,qCAOC;IAED,kFAAkF;IAClF,oBAOC;IAED,qDAAqD;IACrD,uBA4BC;IAED,yHAAyH;IACzH,yCAsCC;IAED,0HAA0H;IAC1H,yBAGC;IAED,sBAGC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED,yDAAyD;IACzD,yBASC;IAED;;;SAGK;IACL,oCAGC;IAED,yCAGC;CACF;8BA3a6B,4BAA4B;iCALzB,2CAA2C"}

package/dist/types/features/utils/feature-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/feature-base.js"],"names":[],"mappings":"AAGA;IACE,qEAeC;IAdC,qBAAqB;IACrB,iBADW,MAAM,CACqB;IACtC,yBAAyB;IACzB,uBAA4B;IAC5B,2BAA2B;IAC3B,iBAAmF;IACnF,qBAAqB;IACrB,aADW,MAAM,CACa;IAC9B;;;;OAIG;IACH,SAFU,OAAO,CAEG;CAEvB"}
+{"version":3,"file":"feature-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/feature-base.js"],"names":[],"mappings":"AAEA;IACE,qEAeC;IAdC,qBAAqB;IACrB,iBADW,MAAM,CACqB;IACtC,yBAAyB;IACzB,uBAA4B;IAC5B,2BAA2B;IAC3B,iBAAiC;IACjC,qBAAqB;IACrB,aADW,MAAM,CACa;IAC9B;;;;OAIG;IACH,SAFU,OAAO,CAEG;CAEvB"}

package/dist/types/loaders/api/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAkBA,2CAoBC;AAED;;;;;IA0DE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;EA0FvB;AA3LD,0CAA0C"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAkBA,2CAoBC;AAED;;;;;IAyDE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;EA0FvB;AA1LD,0CAA0C"}

package/dist/types/loaders/api/apiAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apiAsync.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/apiAsync.js"],"names":[],"mappings":"AAUA,mDAkFC"}
+{"version":3,"file":"apiAsync.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/apiAsync.js"],"names":[],"mappings":"AAQA,mDA8CC"}

package/dist/types/loaders/configure/public-path.d.ts

@@ -1,2 +1,2 @@
-export function redefinePublicPath(url: any): void;
+export function redefinePublicPath(urlString: any): void;
 //# sourceMappingURL=public-path.d.ts.map

package/dist/types/loaders/configure/public-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-path.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/public-path.js"],"names":[],"mappings":"AAEO,mDAGN"}
+{"version":3,"file":"public-path.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/public-path.js"],"names":[],"mappings":"AAEO,yDAMN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.242.0",
+  "version": "1.243.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -266,6 +266,6 @@
     "src",
     "LICENSE",
     "README.md",
-    "types.ts"
+    "CHANGELOG.md"
   ]
 }

package/src/common/session/session-entity.js

@@ -11,6 +11,7 @@ import { getModeledObject } from '../config/state/configurable'
 import { handle } from '../event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { FEATURE_NAMES } from '../../loaders/features/features'
+import { windowAddEventListener } from '../event-listener/event-listener-opts'
 
 export const MODE = {
   OFF: 0,
@@ -25,13 +26,20 @@ const model = {
   expiresAt: 0,
   updatedAt: Date.now(),
   sessionReplay: MODE.OFF,
+  sessionReplaySentFirstChunk: false,
   sessionTraceMode: MODE.OFF,
   custom: {}
 }
 export const SESSION_EVENTS = {
   PAUSE: 'session-pause',
   RESET: 'session-reset',
-  RESUME: 'session-resume'
+  RESUME: 'session-resume',
+  UPDATE: 'session-update'
+}
+
+export const SESSION_EVENT_TYPES = {
+  SAME_TAB: 'same-tab',
+  CROSS_TAB: 'cross-tab'
 }
 
 export class SessionEntity {
@@ -57,6 +65,16 @@ export class SessionEntity {
     this.ee = ee.get(agentIdentifier)
     wrapEvents(this.ee)
     this.setup(opts)
+
+    if (isBrowserScope) {
+      windowAddEventListener('storage', (event) => {
+        if (event.key === this.lookupKey) {
+          const obj = typeof event.newValue === 'string' ? JSON.parse(event.newValue) : event.newValue
+          this.sync(obj)
+          this.ee.emit(SESSION_EVENTS.UPDATE, [SESSION_EVENT_TYPES.CROSS_TAB, this.state])
+        }
+      })
+    }
   }
 
   setup ({ value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
@@ -189,6 +207,7 @@ export class SessionEntity {
       //
       // TODO - compression would need happen here if we decide to do it
       this.storage.set(this.lookupKey, stringify(this.state))
+      this.ee.emit(SESSION_EVENTS.UPDATE, [SESSION_EVENT_TYPES.SAME_TAB, this.state])
       return data
     } catch (e) {
       // storage is inaccessible

package/src/common/wrap/wrap-function.js

@@ -215,5 +215,5 @@ function copy (from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable (fn) {
-  return !(fn && fn instanceof Function && fn.apply && !fn[flag])
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag])
 }

package/src/features/ajax/aggregate/index.js

@@ -81,8 +81,6 @@ export class Aggregate extends AggregateBase {
         hash = stringify([params.status, params.host, params.pathname])
       }
 
-      handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, ee)
-
       // store as metric
       aggregator.store('xhr', hash, params, metrics)
 
@@ -98,6 +96,8 @@ export class Aggregate extends AggregateBase {
         return
       }
 
+      handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, ee)
+
       var xhrContext = this
 
       var event = {