@newrelic/browser-agent 1.255.0 → 1.256.1

package/dist/types/common/constants/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ,2BAA2E;AAE3E,yCAAqE;AAErE,4BAAyI"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ,2BAA2E;AAE3E,yCAAqE;AAErE,4BAAgE"}

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":"AA6BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAwEC;IAjEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;IAexC,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,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBApSqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AA6BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAyEC;IAlEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAkBsC;IAexC,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,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBArSqB,gBAAgB;iCAGL,4BAA4B"}

package/dist/types/common/timer/interaction-timer.d.ts

@@ -2,6 +2,8 @@ export class InteractionTimer extends Timer {
     onPause: any;
     onRefresh: any;
     onResume: any;
+    /** used to double-check LS state at resume time */
+    readStorage: any;
     remainingMs: number | undefined;
     abortController: AbortController | undefined;
     ee: any;

package/dist/types/common/timer/interaction-timer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-timer.d.ts","sourceRoot":"","sources":["../../../../src/common/timer/interaction-timer.js"],"names":[],"mappings":"AAKA;IAGI,aAAuF;IACvF,eAA6F;IAC7F,cAA0F;IAG1F,gCAA4B;IAM1B,6CAA4C;IAO1C,QAAiB;IAEjB,kDAIC;IAoBP,cAQC;IAED,cAIC;IAED,eAGC;IAED,gCAMC;CACF;sBAhFqB,SAAS"}
+{"version":3,"file":"interaction-timer.d.ts","sourceRoot":"","sources":["../../../../src/common/timer/interaction-timer.js"],"names":[],"mappings":"AAKA;IAGI,aAAuF;IACvF,eAA6F;IAC7F,cAA0F;IAE1F,mDAAmD;IACnD,iBAAmC;IAGnC,gCAA4B;IAM1B,6CAA4C;IAO1C,QAAiB;IAEjB,kDAIC;IAoBP,cAQC;IAED,cAIC;IAED,eAeC;IAED,gCAMC;CACF;sBA/FqB,SAAS"}

package/dist/types/common/timing/time-keeper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IA+BE,oBAEC;IAED,yBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAoBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;;CACF"}
+{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IA+BE,oBAEC;IAED,yBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAoBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;;CACF"}

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

@@ -10,6 +10,7 @@ export class Aggregate extends AggregateBase {
     bufferedErrorsUnderSpa: {};
     currentBody: {} | null | undefined;
     errorOnPage: boolean;
+    replayAborted: boolean;
     onHarvestStarted(options: any): {
         body: {} | null;
         qs: {};
@@ -25,7 +26,7 @@ export class Aggregate extends AggregateBase {
      * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
      */
     buildCanonicalStackString(stackInfo: StackInfo): string;
-    storeError(err: any, time: any, internal: any, customAttributes: any): void;
+    storeError(err: any, time: any, internal: any, customAttributes: any, hasReplay: any): void;
     onInteractionDone(interaction: any, wasSaved: any): void;
     onSoftNavNotification(interactionId: any, wasFinished: any, softNavAttrs: any): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IA0B1B;;;MAoBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4EAuFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAvQY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IACxB,uBAA0B;IA4B5B;;;MA2BC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FAsFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAhRY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}

package/dist/types/features/jserrors/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAeA;IACE,2BAAiC;IAIjC,mEA4CC;IAvCG,2CAA0C;IAqC5C,yBAA+B;;CAoFlC;+BA5I8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IAKjC,mEA+CC;IA1CG,2CAA0C;IAwC5C,yBAA+B;;CAoFlC;+BAjJ8B,6BAA6B"}

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

@@ -1,6 +1,7 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any, args: any);
+    mode: number;
     /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
     harvestTimeSeconds: any;
     /** Set once the recorder has fully initialized after flag checks and sampling */
@@ -9,14 +10,15 @@ export class Aggregate extends AggregateBase {
     gzipper: typeof import("fflate").gzipSync | undefined;
     /** populated with the u8 string lib async */
     u8: typeof import("fflate").strToU8 | undefined;
-    mode: any;
     /** set by BCS response */
     entitled: boolean;
     /** set at BCS response, stored in runtime */
     timeKeeper: any;
     recorder: any;
+    preloaded: boolean;
+    errorNoticed: any;
     scheduler: HarvestScheduler;
-    errorNoticed: boolean;
+    handleError(e: any): void;
     switchToFull(): void;
     /**
      * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
@@ -41,6 +43,7 @@ export class Aggregate extends AggregateBase {
         };
         body: any;
     }[] | undefined;
+    getCorrectedTimestamp(node: any): any;
     getHarvestContents(recorderEvents: any): {
         qs: {
             browser_monitoring_key: any;

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":"AA+BA;IACE,2BAAiC;IAEjC,8DAoHC;IAlHC,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAGnB,UAAuD;IAEvD,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IA8B9B,4BAKQ;IAmBN,sBAAwB;IA2C5B,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA6DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAoCC;IAED;;;;;;;;;;MAmEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAtX6B,4BAA4B;iCAHzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAgCA;IACE,2BAAiC;IAIjC,8DAsGC;IAzGD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,mBAAgC;IAChC,kBAA+C;IA4B/C,4BAKQ;IAmDV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAoEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAxY6B,4BAA4B;iCAHzB,2CAA2C"}

package/dist/types/features/session_replay/constants.d.ts

@@ -2,6 +2,7 @@ export const FEATURE_NAME: string;
 export namespace SR_EVENT_EMITTER_TYPES {
     let RECORD: string;
     let PAUSE: string;
+    let REPLAY_RUNNING: string;
 }
 export const AVG_COMPRESSION: 0.12;
 export namespace RRWEB_EVENT_TYPES {

package/dist/types/features/session_replay/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;AAOvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;;AAQvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}

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

@@ -1,6 +1,7 @@
 export class Instrument extends InstrumentBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any, auto?: boolean);
+    errorNoticed: boolean;
     recorder: import("../shared/recorder").Recorder | undefined;
     #private;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mEAYC;IAiBC,4DAA6E;;CAKhF;+BAxC8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mEAiBC;IAPK,sBAAwB;IAwB5B,4DAA0F;;CAK7F;+BA7C8B,6BAA6B"}

package/dist/types/features/session_replay/shared/recorder-events.d.ts

@@ -1,18 +1,10 @@
 export class RecorderEvents {
-    constructor({ canCorrectTimestamps }: {
-        canCorrectTimestamps: any;
-    });
     /** The buffer to hold recorder event nodes */
     events: any[];
     /** 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
      */
     cycleTimestamp: number;
-    /** Payload metadata -- Whether timestamps can be corrected, defaults as false, can be set to true if timekeeper is present at init time.  Used to determine
-     * if harvest needs to re-loop through nodes and correct them before sending.  Ideal behavior is to correct them as they flow into the recorder
-     * to prevent re-looping, but is not always possible since the timekeeper is not set until after page load and the recorder can be preloaded.
-    */
-    canCorrectTimestamps: boolean;
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     payloadBytesEstimation: number;
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen

package/dist/types/features/session_replay/shared/recorder-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAAA;IACE;;OAyBC;IAxBC,8CAA8C;IAC9C,cAAgB;IAChB;;OAEG;IACH,uBAAgC;IAChC;;;MAGE;IACF,8BAAkD;IAClD,qGAAqG;IACrG,+BAA+B;IAC/B;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IACrB,0FAA0F;IAC1F,+BAAiC;IAGnC,sBAEC;CACF"}
+{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAAA;IAEI,8CAA8C;IAC9C,cAAgB;IAChB;;OAEG;IACH,uBAAgC;IAChC,qGAAqG;IACrG,+BAA+B;IAC/B;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IACrB,0FAA0F;IAC1F,+BAAiC;IAGnC,sBAEC;CACF"}

package/dist/types/features/session_replay/shared/recorder.d.ts

@@ -15,31 +15,15 @@ export class Recorder {
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     stopRecording: () => void;
     getEvents(): {
-        events: CorrectedSessionReplayEvent[];
         type: string;
+        events: any[];
         cycleTimestamp: number;
-        canCorrectTimestamps: boolean;
         payloadBytesEstimation: number;
         hasSnapshot: boolean;
         hasMeta: boolean;
         hasError: boolean;
         inlinedAllStylesheets: boolean;
-    } | {
-        events: any[];
-        type: string;
-        cycleTimestamp: number;
-        payloadBytesEstimation: number;
-        hasError: boolean;
-        hasMeta: boolean;
-        hasSnapshot: boolean;
-        inlinedAllStylesheets: boolean;
     };
-    /**
-     * Returns time-corrected events. If the events were correctable from the beginning, this correction will have already been applied.
-     * @param {SessionReplayEvent[]} events The array of buffered SR nodes
-     * @returns {CorrectedSessionReplayEvent[]}
-     */
-    returnCorrectTimestamps(events: SessionReplayEvent[]): CorrectedSessionReplayEvent[];
     /** Clears the buffer (this.#events), and resets all payload metadata properties */
     clearBuffer(): void;
     /** Begin recording using configured recording lib */

package/dist/types/features/session_replay/shared/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAWA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;;;;;;;;;;;MAiBC;IAED;;;;OAIG;IACH,gCAHW,oBAAoB,GAClB,6BAA6B,CAOzC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAwBC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCA+CC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAvN8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAYA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAYC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAgDC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAjN8B,mBAAmB"}

package/dist/types/features/session_replay/shared/utils.d.ts

@@ -1,4 +1,12 @@
 export function isPreloadAllowed(agentId: any): any;
 export function canImportReplayAgg(agentId: any, sessionMgr: any): boolean;
+export function buildNRMetaNode(timestamp: any, timeKeeper: any): {
+    originalTimestamp: any;
+    correctedTimestamp: any;
+    timestampDiff: number;
+    timeKeeperOriginTime: any;
+    timeKeeperCorrectedOriginTime: any;
+    timeKeeperDiff: number;
+};
 export function enableSessionTracking(agentId: any): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/features/session_replay/shared/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAWA,oDAEC;AAED,2EAGC;AAfM,6DAA+H"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAWA,oDAEC;AAED,2EAGC;AAED;;;;;;;EAUC;AA3BM,6DAA+H"}

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,2CAeC;AAED;;;;IAiDE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EA0GvB"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAmBA,2CAeC;AAID;;;;IAuDE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EA0GvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.255.0",
+  "version": "1.256.1",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -168,7 +168,7 @@
   "dependencies": {
     "core-js": "^3.26.0",
     "fflate": "^0.7.4",
-    "rrweb": "2.0.0-alpha.11",
+    "rrweb": "2.0.0-alpha.12",
     "web-vitals": "^3.1.0"
   },
   "devDependencies": {

package/src/common/constants/runtime.js

@@ -74,4 +74,4 @@ export const isIE = Boolean(isBrowserScope && window.document.documentMode) // d
 
 export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon
 
-export const offset = Math.floor(globalScope?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now())
+export const offset = Math.floor(Date.now() - performance.now())

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

@@ -117,7 +117,8 @@ export class SessionEntity {
           this.write(getModeledObject(this.state, model))
         },
         ee: this.ee,
-        refreshEvents: ['click', 'keydown', 'scroll']
+        refreshEvents: ['click', 'keydown', 'scroll'],
+        readStorage: () => this.storage.get(this.lookupKey)
       }, this.state.inactiveAt - Date.now())
     } else {
       this.state.inactiveAt = Infinity

package/src/common/timer/interaction-timer.js

@@ -10,6 +10,9 @@ export class InteractionTimer extends Timer {
     this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => { /* noop */ }
     this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => { /* noop */ }
 
+    /** used to double-check LS state at resume time */
+    this.readStorage = opts.readStorage
+
     // used by pause/resume
     this.remainingMs = undefined
 
@@ -67,8 +70,20 @@ export class InteractionTimer extends Timer {
   }
 
   resume () {
-    this.refresh()
-    this.onResume() // emit resume event after state updated
+    try {
+      const lsData = this.readStorage()
+      const obj = typeof lsData === 'string' ? JSON.parse(lsData) : lsData
+      if (isExpired(obj.expiresAt) || isExpired(obj.inactiveAt)) this.end()
+      else {
+        this.refresh()
+        this.onResume() // emit resume event after state updated
+      }
+    } catch (err) {
+      this.end()
+    }
+    function isExpired (timestamp) {
+      return Date.now() > timestamp
+    }
   }
 
   refresh (cb, ms) {

package/src/common/timing/time-keeper.js

@@ -1,5 +1,3 @@
-import { globalScope } from '../constants/runtime'
-
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -33,7 +31,7 @@ export class TimeKeeper {
   #ready = false
 
   constructor () {
-    this.#originTime = globalScope.performance.timeOrigin || globalScope.performance.timing.navigationStart
+    this.#originTime = Date.now() - performance.now()
   }
 
   get ready () {

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

@@ -38,10 +38,13 @@ export class Aggregate extends AggregateBase {
     this.bufferedErrorsUnderSpa = {}
     this.currentBody = undefined
     this.errorOnPage = false
+    this.replayAborted = false
 
     // this will need to change to match whatever ee we use in the instrument
     this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved))
 
+    this.ee.on('REPLAY_ABORTED', () => { this.replayAborted = true })
+
     register('err', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs) =>
@@ -78,9 +81,16 @@ export class Aggregate extends AggregateBase {
       payload.qs.ri = releaseIds
     }
 
-    if (body && body.err && body.err.length && !this.errorOnPage) {
-      payload.qs.pve = '1'
-      this.errorOnPage = true
+    if (body && body.err && body.err.length) {
+      if (this.replayAborted) {
+        body.err.forEach((e) => {
+          delete e.params?.hasReplay
+        })
+      }
+      if (!this.errorOnPage) {
+        payload.qs.pve = '1'
+        this.errorOnPage = true
+      }
     }
     return payload
   }
@@ -133,7 +143,7 @@ export class Aggregate extends AggregateBase {
     return canonicalStackString
   }
 
-  storeError (err, time, internal, customAttributes) {
+  storeError (err, time, internal, customAttributes, hasReplay) {
     // are we in an interaction
     time = time || now()
     const agentRuntime = getRuntime(this.agentIdentifier)
@@ -189,7 +199,7 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
-    if (agentRuntime?.session?.state?.sessionReplayMode) params.hasReplay = true
+    if (hasReplay && !this.replayAborted) params.hasReplay = hasReplay
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
     params.timestamp = this.observedAt[bucketHash]
 
@@ -199,7 +209,6 @@ export class Aggregate extends AggregateBase {
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
     handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
-    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionReplay, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 

package/src/features/jserrors/instrument/index.js

@@ -12,11 +12,13 @@ import { eventListenerOpts } from '../../../common/event-listener/event-listener
 import { stringify } from '../../../common/util/stringify'
 import { UncaughtError } from './uncaught-error'
 import { now } from '../../../common/timing/now'
+import { SR_EVENT_EMITTER_TYPES } from '../../session_replay/constants'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
 
   #seenErrors = new Set()
+  #replayRunning = false
 
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
@@ -36,13 +38,16 @@ export class Instrument extends InstrumentBase {
 
     this.ee.on('internal-error', (error) => {
       if (!this.abortHandler) return
-      handle('ierr', [this.#castError(error), now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('ierr', [this.#castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+    })
+
+    this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
+      this.#replayRunning = isRunning
     })
 
     globalScope.addEventListener('unhandledrejection', (promiseRejectionEvent) => {
       if (!this.abortHandler) return
-
-      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     globalScope.addEventListener('error', (errorEvent) => {
@@ -57,7 +62,7 @@ export class Instrument extends InstrumentBase {
         return
       }
 
-      handle('err', [this.#castErrorEvent(errorEvent), now()], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [this.#castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     this.abortHandler = this.#abort // we also use this as a flag to denote that the feature is active or on and handling errors

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

@@ -28,9 +28,12 @@ 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'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
+  mode = MODE.OFF
+
   // pass the recorder into the aggregator
   constructor (agentIdentifier, aggregator, args) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -44,9 +47,6 @@ export class Aggregate extends AggregateBase {
     this.gzipper = undefined
     /** populated with the u8 string lib async */
     this.u8 = undefined
-    /** the mode to start in.  Defaults to off */
-    const { session } = getRuntime(this.agentIdentifier)
-    this.mode = session.state.sessionReplayMode || MODE.OFF
 
     /** set by BCS response */
     this.entitled = false
@@ -54,13 +54,13 @@ export class Aggregate extends AggregateBase {
     this.timeKeeper = undefined
 
     this.recorder = args?.recorder
-    if (this.recorder) this.recorder.parent = this
+    this.preloaded = !!this.recorder
+    this.errorNoticed = args?.errorNoticed || false
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
     // 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.scheduler.runHarvest()
       this.abort(ABORT_REASONS.RESET)
     })
 
@@ -104,17 +104,6 @@ export class Aggregate extends AggregateBase {
       this.forceStop(this.mode !== MODE.ERROR)
     }, this.featureName, this.ee)
 
-    // Wait for an error to be reported.  This currently is wrapped around the "Error" feature.  This is a feature-feature dependency.
-    // This was to ensure that all errors, including those on the page before load and those handled with "noticeError" are accounted for. Needs evalulation
-    registerHandler('errorAgg', (e) => {
-      this.errorNoticed = true
-      if (this.recorder) this.recorder.currentBufferTarget.hasError = true
-      // run once
-      if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
-        this.switchToFull()
-      }
-    }, this.featureName, this.ee)
-
     const { error_sampling_rate, sampling_rate, autoStart, block_selector, mask_text_selector, mask_all_inputs, inline_stylesheet, inline_images, collect_fonts } = getConfigurationValue(this.agentIdentifier, 'session_replay')
 
     this.waitForFlags(['sr']).then(([flagOn]) => {
@@ -150,6 +139,14 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee)
   }
 
+  handleError (e) {
+    if (this.recorder) this.recorder.currentBufferTarget.hasError = true
+    // run once
+    if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
+      this.switchToFull()
+    }
+  }
+
   switchToFull () {
     this.mode = MODE.FULL
     // if the error was noticed AFTER the recorder was already imported....
@@ -210,12 +207,13 @@ export class Aggregate extends AggregateBase {
       } catch (err) {
         return this.abort(ABORT_REASONS.IMPORT)
       }
+    } else {
+      this.recorder.parent = this
     }
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
-    if (this.mode === MODE.ERROR && this.errorNoticed) {
-      this.mode = MODE.FULL
-    }
+    if (this.mode === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL
+    if (!this.preloaded) this.ee.on('err', e => this.handleError(e))
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
     // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
@@ -255,16 +253,29 @@ export class Aggregate extends AggregateBase {
       return
     }
 
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Harvest/Attempts'], undefined, FEATURE_NAMES.metrics, this.ee)
+
     let len = 0
     if (!!this.gzipper && !!this.u8) {
-      payload.body = this.gzipper(this.u8(`[${payload.body.map(e => {
-        if (e.__serialized) return e.__serialized
-        return stringify(e)
+      payload.body = this.gzipper(this.u8(`[${payload.body.map(({ __serialized, ...e }) => {
+        if (e.__newrelic && __serialized) return __serialized
+        const output = { ...e }
+        if (!output.__newrelic) {
+          output.__newrelic = buildNRMetaNode(e.timestamp, this.timeKeeper)
+          output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(e.timestamp)
+        }
+        return stringify(output)
       }).join(',')}]`))
       len = payload.body.length
       this.scheduler.opts.gzip = true
     } else {
-      payload.body = payload.body.map(({ __serialized, ...node }) => node)
+      payload.body = payload.body.map(({ __serialized, ...node }) => {
+        if (node.__newrelic) return node
+        const output = { ...node }
+        output.__newrelic = buildNRMetaNode(node.timestamp, this.timeKeeper)
+        output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
+        return output
+      })
       len = stringify(payload.body).length
       this.scheduler.opts.gzip = false
     }
@@ -281,6 +292,12 @@ export class Aggregate extends AggregateBase {
     return [payload]
   }
 
+  getCorrectedTimestamp (node) {
+    if (!node.timestamp) return
+    if (node.__newrelic) return node.timestamp
+    return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
+  }
+
   getHarvestContents (recorderEvents) {
     recorderEvents ??= this.recorder.getEvents()
     let events = recorderEvents.events
@@ -308,8 +325,8 @@ export class Aggregate extends AggregateBase {
 
     const relativeNow = now()
 
-    const firstEventTimestamp = events[0]?.timestamp // from rrweb node
-    const lastEventTimestamp = events[events.length - 1]?.timestamp // from rrweb node
+    const firstEventTimestamp = this.getCorrectedTimestamp(events[0]) // from rrweb node
+    const lastEventTimestamp = this.getCorrectedTimestamp(events[events.length - 1]) // from rrweb node
     const firstTimestamp = firstEventTimestamp || this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp) // from rrweb node || from when the harvest cycle started
     const lastTimestamp = lastEventTimestamp || this.timeKeeper.convertRelativeTimestamp(relativeNow)
 
@@ -341,6 +358,7 @@ export class Aggregate extends AggregateBase {
           invalidStylesheetsDetected: stylesheetEvaluator.invalidStylesheetsDetected,
           inlinedAllStylesheets: recorderEvents.inlinedAllStylesheets,
           'rrweb.version': RRWEB_VERSION,
+          'payload.type': recorderEvents.type,
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && { 'enduser.id': endUserId })
           // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()

package/src/features/session_replay/constants.js

@@ -5,7 +5,8 @@ export const FEATURE_NAME = FEATURE_NAMES.sessionReplay
 
 export const SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
-  PAUSE: 'pauseReplay'
+  PAUSE: 'pauseReplay',
+  REPLAY_RUNNING: 'replayRunning'
 }
 
 export const AVG_COMPRESSION = 0.12

package/src/features/session_replay/instrument/index.js

@@ -24,6 +24,11 @@ export class Instrument extends InstrumentBase {
     } catch (err) { }
 
     if (this.#canPreloadRecorder(session)) {
+      /** If this is preloaded, set up a buffer, if not, later when sampling we will set up a .on for live events */
+      this.ee.on('err', (e) => {
+        this.errorNoticed = true
+        if (this.featAggregate) this.featAggregate.handleError()
+      })
       this.#startRecording(session?.sessionReplayMode)
     } else {
       this.importAggregator()
@@ -45,9 +50,9 @@ export class Instrument extends InstrumentBase {
 
   async #startRecording (mode) {
     const { Recorder } = (await import(/* webpackChunkName: "recorder" */'../shared/recorder'))
-    this.recorder = new Recorder({ mode, agentIdentifier: this.agentIdentifier })
+    this.recorder = new Recorder({ mode, agentIdentifier: this.agentIdentifier, ee: this.ee })
     this.recorder.startRecording()
     this.abortHandler = this.recorder.stopRecording
-    this.importAggregator({ recorder: this.recorder })
+    this.importAggregator({ recorder: this.recorder, errorNoticed: this.errorNoticed })
   }
 }

package/src/features/session_replay/shared/recorder-events.js

@@ -1,16 +1,11 @@
 export class RecorderEvents {
-  constructor ({ canCorrectTimestamps }) {
+  constructor () {
     /** The buffer to hold recorder event nodes */
     this.events = []
     /** 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.cycleTimestamp = Date.now()
-    /** Payload metadata -- Whether timestamps can be corrected, defaults as false, can be set to true if timekeeper is present at init time.  Used to determine
-     * if harvest needs to re-loop through nodes and correct them before sending.  Ideal behavior is to correct them as they flow into the recorder
-     * to prevent re-looping, but is not always possible since the timekeeper is not set until after page load and the recorder can be preloaded.
-    */
-    this.canCorrectTimestamps = !!canCorrectTimestamps
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen