@newrelic/browser-agent 1.258.2 → 1.260.0

package/dist/esm/features/session_trace/aggregate/trace/node.js

@@ -0,0 +1,12 @@
+/**
+ * All nodes reported to the consumer must take this shape
+ */
+export class TraceNode {
+  constructor(name, start, end, origin, type) {
+    this.n = name;
+    this.s = start;
+    this.e = end;
+    this.o = origin;
+    this.t = type;
+  }
+}

package/dist/esm/features/session_trace/aggregate/trace/storage.js

@@ -0,0 +1,282 @@
+import { globalScope } from '../../../../common/constants/runtime';
+import { MODE } from '../../../../common/session/constants';
+import { now } from '../../../../common/timing/now';
+import { parseUrl } from '../../../../common/url/parse-url';
+import { MAX_NODES_PER_HARVEST } from '../../constants';
+import { TraceNode } from './node';
+const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
+const SUPPORTS_PERFORMANCE_OBSERVER = typeof globalScope.PerformanceObserver === 'function';
+const ignoredEvents = {
+  // we find that certain events make the data too noisy to be useful
+  global: {
+    mouseup: true,
+    mousedown: true
+  },
+  // certain events are present both in the window and in PVT metrics.  PVT metrics are prefered so the window events should be ignored
+  window: {
+    load: true,
+    pagehide: true
+  },
+  // when ajax instrumentation is disabled, all XMLHttpRequest events will return with origin = xhrOriginMissing and should be ignored
+  xhrOriginMissing: {
+    ignoreAll: true
+  }
+};
+const toAggregate = {
+  typing: [1000, 2000],
+  scrolling: [100, 1000],
+  mousing: [1000, 2000],
+  touching: [1000, 2000]
+};
+
+/** The purpose of this class is to manage, normalize, and retrieve ST nodes as needed without polluting the main ST modules */
+export class TraceStorage {
+  nodeCount = 0;
+  trace = {};
+  earliestTimeStamp = Infinity;
+  latestTimeStamp = 0;
+  tempStorage = [];
+  prevStoredEvents = new Set();
+  constructor(parent) {
+    this.parent = parent;
+  }
+
+  /** Central function called by all the other store__ & addToTrace API to append a trace node. */
+  storeSTN(stn) {
+    if (this.parent.blocked) return;
+    if (this.nodeCount >= MAX_NODES_PER_HARVEST) {
+      // limit the amount of pending data awaiting next harvest
+      if (this.parent.agentRuntime.session.state.sessionTraceMode !== MODE.ERROR) return;
+      const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
+      if (openedSpace === 0) return;
+    }
+    while (this.tempStorage.length) {
+      this.storeSTN(this.tempStorage.shift());
+    }
+    if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
+    if (stn.s < this.earliestTimeStamp) this.earliestTimeStamp = stn.s;
+    if (stn.s > this.latestTimeStamp) this.latestTimeStamp = stn.s;
+    this.nodeCount++;
+  }
+
+  /**
+   * Trim the collection of nodes awaiting harvest such that those seen outside a certain span of time are discarded.
+   * @param {number} lookbackDuration Past length of time until now for which we care about nodes, in milliseconds
+   * @returns {number} However many nodes were discarded after trimming.
+   */
+  trimSTNs(lookbackDuration) {
+    let prunedNodes = 0;
+    const cutoffHighResTime = Math.max(now() - lookbackDuration, 0);
+    Object.keys(this.trace).forEach(nameCategory => {
+      const nodeList = this.trace[nameCategory];
+      /* Notice nodes are appending under their name's list as they end and are stored. This means each list is already (roughly) sorted in chronological order by end time.
+         * This isn't exact since nodes go through some processing & EE handlers chain, but it's close enough as we still capture nodes whose duration overlaps the lookback window.
+         * ASSUMPTION: all 'end' timings stored are relative to timeOrigin (DOMHighResTimeStamp) and not Unix epoch based. */
+      let cutoffIdx = nodeList.findIndex(node => cutoffHighResTime <= node.e);
+      if (cutoffIdx === 0) return;else if (cutoffIdx < 0) {
+        // whole list falls outside lookback window and is irrelevant
+        cutoffIdx = nodeList.length;
+        delete this.trace[nameCategory];
+      } else nodeList.splice(0, cutoffIdx); // chop off everything outside our window i.e. before the last <lookbackDuration> timeframe
+
+      this.nodeCount -= cutoffIdx;
+      prunedNodes += cutoffIdx;
+    });
+    return prunedNodes;
+  }
+
+  /** Used by session trace's harvester to create the payload body. */
+  takeSTNs() {
+    if (!SUPPORTS_PERFORMANCE_OBSERVER) {
+      // if PO isn't supported, this checks resourcetiming buffer every harvest.
+      this.storeResources(globalScope.performance?.getEntriesByType?.('resource'));
+    }
+    const stns = Object.entries(this.trace).flatMap(_ref => {
+      let [name, listOfSTNodes] = _ref;
+      // basically take the "this.trace" map-obj and concat all the list-type values
+      if (!(name in toAggregate)) return listOfSTNodes;
+      // Special processing for event nodes dealing with user inputs:
+      const reindexByOriginFn = this.smearEvtsByOrigin(name);
+      const partitionListByOriginMap = listOfSTNodes.sort((a, b) => a.s - b.s).reduce(reindexByOriginFn, {});
+      return Object.values(partitionListByOriginMap).flat(); // join the partitions back into 1-D, now ordered by origin then start time
+    }, this);
+    if (stns.length === 0) return {};
+    this.trace = {};
+    this.nodeCount = 0;
+    const earliestTimeStamp = this.earliestTimeStamp;
+    this.earliestTimeStamp = Infinity;
+    const latestTimeStamp = this.latestTimeStamp;
+    this.latestTimeStamp = 0;
+    return {
+      stns,
+      earliestTimeStamp,
+      latestTimeStamp
+    };
+  }
+  smearEvtsByOrigin(name) {
+    const maxGap = toAggregate[name][0];
+    const maxLen = toAggregate[name][1];
+    const lastO = {};
+    return (byOrigin, evtNode) => {
+      let lastArr = byOrigin[evtNode.o];
+      if (!lastArr) lastArr = byOrigin[evtNode.o] = [];
+      const last = lastO[evtNode.o];
+      if (name === 'scrolling' && !trivial(evtNode)) {
+        lastO[evtNode.o] = null;
+        evtNode.n = 'scroll';
+        lastArr.push(evtNode);
+      } else if (last && evtNode.s - last.s < maxLen && last.e > evtNode.s - maxGap) {
+        last.e = evtNode.e;
+      } else {
+        lastO[evtNode.o] = evtNode;
+        lastArr.push(evtNode);
+      }
+      return byOrigin;
+    };
+    function trivial(node) {
+      const limit = 4;
+      return !!(node && typeof node.e === 'number' && typeof node.s === 'number' && node.e - node.s < limit);
+    }
+  }
+  processPVT(name, value, attrs) {
+    this.storeTiming({
+      [name]: value
+    });
+    if (hasFID(name, attrs)) this.storeEvent({
+      type: 'fid',
+      target: 'document'
+    }, 'document', value, value + attrs.fid);
+    function hasFID(name, attrs) {
+      return name === 'fi' && !!attrs && typeof attrs.fid === 'number';
+    }
+  }
+  storeTiming(timingEntry) {
+    if (!timingEntry) return;
+
+    // loop iterates through prototype also (for FF)
+    for (let key in timingEntry) {
+      let val = timingEntry[key];
+
+      // ignore size and status type nodes that do not map to timestamp metrics
+      const lck = key.toLowerCase();
+      if (lck.indexOf('size') >= 0 || lck.indexOf('status') >= 0) continue;
+
+      // ignore inherited methods, meaningless 0 values, and bogus timestamps
+      // that are in the future (Microsoft Edge seems to sometimes produce these)
+      if (!(typeof val === 'number' && val >= 0)) continue;
+      val = Math.round(val);
+      this.storeSTN(new TraceNode(key, val, val, 'document', 'timing'));
+    }
+  }
+
+  // Tracks the events and their listener's duration on objects wrapped by wrap-events.
+  storeEvent(currentEvent, target, start, end) {
+    if (this.shouldIgnoreEvent(currentEvent, target)) return;
+    if (this.prevStoredEvents.has(currentEvent)) return; // prevent multiple listeners of an event from creating duplicate trace nodes per occurrence. Cleared every harvest. near-zero chance for re-duplication after clearing per harvest since the timestamps of the event are considered for uniqueness.
+    this.prevStoredEvents.add(currentEvent);
+    const evt = new TraceNode(this.evtName(currentEvent.type), start, end, undefined, 'event');
+    try {
+      // webcomponents-lite.js can trigger an exception on currentEvent.target getter because
+      // it does not check currentEvent.currentTarget before calling getRootNode() on it
+      evt.o = this.evtOrigin(currentEvent.target, target);
+    } catch (e) {
+      evt.o = this.evtOrigin(null, target);
+    }
+    this.storeSTN(evt);
+  }
+  shouldIgnoreEvent(event, target) {
+    const origin = this.evtOrigin(event.target, target);
+    if (event.type in ignoredEvents.global) return true;
+    if (!!ignoredEvents[origin] && ignoredEvents[origin].ignoreAll) return true;
+    return !!(!!ignoredEvents[origin] && event.type in ignoredEvents[origin]);
+  }
+  evtName(type) {
+    switch (type) {
+      case 'keydown':
+      case 'keyup':
+      case 'keypress':
+        return 'typing';
+      case 'mousemove':
+      case 'mouseenter':
+      case 'mouseleave':
+      case 'mouseover':
+      case 'mouseout':
+        return 'mousing';
+      case 'scroll':
+        return 'scrolling';
+      case 'touchstart':
+      case 'touchmove':
+      case 'touchend':
+      case 'touchcancel':
+      case 'touchenter':
+      case 'touchleave':
+        return 'touching';
+      default:
+        return type;
+    }
+  }
+  evtOrigin(t, target) {
+    let origin = 'unknown';
+    if (t && t instanceof XMLHttpRequest) {
+      const params = this.parent.ee.context(t).params;
+      if (!params || !params.status || !params.method || !params.host || !params.pathname) return 'xhrOriginMissing';
+      origin = params.status + ' ' + params.method + ': ' + params.host + params.pathname;
+    } else if (t && typeof t.tagName === 'string') {
+      origin = t.tagName.toLowerCase();
+      if (t.id) origin += '#' + t.id;
+      if (t.className) {
+        for (let i = 0; i < t.classList.length; i++) origin += '.' + t.classList[i];
+      }
+    }
+    if (origin === 'unknown') {
+      if (typeof target === 'string') origin = target;else if (target === document) origin = 'document';else if (target === window) origin = 'window';else if (target instanceof FileReader) origin = 'FileReader';
+    }
+    return origin;
+  }
+
+  // Tracks when the window history API specified by wrap-history is used.
+  storeHist(path, old, time) {
+    this.storeSTN(new TraceNode('history.pushState', time, time, path, old));
+  }
+  #laststart = 0;
+  // Processes all the PerformanceResourceTiming entries captured (by observer).
+  storeResources(resources) {
+    if (!resources || resources.length === 0) return;
+    resources.forEach(currentResource => {
+      if ((currentResource.fetchStart | 0) <= this.#laststart) return; // don't recollect already-seen resources
+
+      const {
+        initiatorType,
+        fetchStart,
+        responseEnd,
+        entryType
+      } = currentResource;
+      const {
+        protocol,
+        hostname,
+        port,
+        pathname
+      } = parseUrl(currentResource.name);
+      const res = new TraceNode(initiatorType, fetchStart | 0, responseEnd | 0, "".concat(protocol, "://").concat(hostname, ":").concat(port).concat(pathname), entryType);
+      this.storeSTN(res);
+    });
+    this.#laststart = resources[resources.length - 1].fetchStart | 0;
+  }
+
+  // JavascriptError (FEATURE) events pipes into ST here.
+  storeErrorAgg(type, name, params, metrics) {
+    if (type !== 'err') return; // internal errors are purposefully ignored
+    this.storeSTN(new TraceNode('error', metrics.time, metrics.time, params.message, params.stackHash));
+  }
+
+  // Ajax (FEATURE) events--XML & fetches--pipes into ST here.
+  storeXhrAgg(type, name, params, metrics) {
+    if (type !== 'xhr') return;
+    this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, "".concat(params.status, " ").concat(params.method, ": ").concat(params.host).concat(params.pathname)));
+  }
+  restoreNode(name, listOfSTNodes) {
+    if (this.nodeCount >= MAX_NODES_PER_HARVEST) return;
+    this.nodeCount += listOfSTNodes.length;
+    this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes;
+  }
+}

package/dist/esm/features/session_trace/constants.js

@@ -6,4 +6,5 @@ export const START = '-start';
 export const END = '-end';
 export const FN_START = 'fn' + START;
 export const FN_END = 'fn' + END;
-export const PUSH_STATE = 'pushState';
+export const PUSH_STATE = 'pushState';
+export const MAX_NODES_PER_HARVEST = 1000;

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

@@ -7,7 +7,8 @@ import { wrapHistory, wrapEvents } from '../../../common/wrap';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { isBrowserScope } from '../../../common/constants/runtime';
+import { deregisterDrain } from '../../../common/drain/drain';
+import { canEnableSessionTracking } from '../../utils/feature-gates';
 import { now } from '../../../common/timing/now';
 const {
   BST_RESOURCE,
@@ -24,8 +25,11 @@ export class Instrument extends InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    if (!isBrowserScope) return; // session traces not supported outside web env
-
+    const canTrackSession = canEnableSessionTracking(this.agentIdentifier);
+    if (!canTrackSession) {
+      deregisterDrain(this.agentIdentifier, this.featureName);
+      return;
+    }
     const thisInstrumentEE = this.ee;
     wrapHistory(thisInstrumentEE);
     this.eventsEE = wrapEvents(thisInstrumentEE);

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

@@ -36,6 +36,7 @@ export class AggregateBase extends FeatureBase {
   }
   drain() {
     drain(this.agentIdentifier, this.featureName);
+    this.drained = true;
   }
 
   /**

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

@@ -0,0 +1,11 @@
+import { getConfigurationValue } from '../../common/config/config';
+import { isBrowserScope } from '../../common/constants/runtime';
+
+/**
+ * Checks if session can be tracked, affects session entity and dependent features
+ * @param {string} agentId
+ * @returns {boolean}
+ */
+export const canEnableSessionTracking = agentId => {
+  return isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true;
+};

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

@@ -11,7 +11,8 @@ import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 import { getConfigurationValue } from '../../common/config/config';
-import { canImportReplayAgg, enableSessionTracking } from '../session_replay/shared/utils';
+import { canImportReplayAgg } from '../session_replay/shared/utils';
+import { canEnableSessionTracking } from './feature-gates';
 import { single } from '../../common/util/invoke';
 
 /**
@@ -78,7 +79,7 @@ export class InstrumentBase extends FeatureBase {
     const importLater = async () => {
       let session;
       try {
-        if (enableSessionTracking(this.agentIdentifier)) {
+        if (canEnableSessionTracking(this.agentIdentifier)) {
           // would require some setup before certain features start
           const {
             setupAgentSession

package/dist/esm/loaders/agent-base.js

@@ -3,6 +3,7 @@
 import { warn } from '../common/util/console';
 import { SR_EVENT_EMITTER_TYPES } from '../features/session_replay/constants';
 import { generateRandomHexString } from '../common/ids/unique-id';
+import { ee } from '../common/event-emitter/contextual-ee';
 
 /**
  * @typedef {import('./api/interaction-types').InteractionInstance} InteractionInstance
@@ -13,6 +14,9 @@ export class AgentBase {
   constructor() {
     let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateRandomHexString(16);
     this.agentIdentifier = agentIdentifier;
+
+    // Assign the observation context to the event emitter, so it knows how to create observation contexts
+    this.ee = ee.get(agentIdentifier);
   }
 
   /**

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

@@ -1,3 +1,3 @@
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
-export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay', SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE];
+export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE];
 export const asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];

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

@@ -198,8 +198,8 @@ export function setAPI(agentIdentifier, forceDrain) {
       } = _ref;
       setAPI(agentIdentifier);
       drain(agentIdentifier, 'api');
-    }).catch(() => {
-      warn('Downloading runtime APIs failed...');
+    }).catch(err => {
+      warn('Downloading runtime APIs failed...', err);
       instanceEE.abort();
     });
   }

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

@@ -54,6 +54,7 @@ export function configure(agent) {
     agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
+  runtime.ptid = agent.agentIdentifier;
   setRuntime(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

package/dist/types/common/harvest/harvest-scheduler.d.ts

@@ -31,6 +31,7 @@ export class HarvestScheduler extends SharedContext {
     started: boolean;
     timeoutHandle: any;
     aborted: boolean;
+    harvesting: boolean;
     harvest: Harvest;
     /**
      * This function is only meant for the last outgoing harvest cycle of a page. It trickles down to using sendBeacon, which should not be used

package/dist/types/common/harvest/harvest-scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harvest-scheduler.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest-scheduler.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;;;;;SAUK;IACL,sBATa,MAAM;QAES,UAAU;QACV,UAAU;QACZ,UAAU,EAAvB,MAAM;QACQ,GAAG,EAAjB,OAAO;QACM,SAAS,EAAtB,MAAM;oBAoBlB;IAfC,iBAAwB;IACxB;;;oBARW,MAAM;aACN,OAAO;mBACP,MAAM;MAMK;IACtB,iBAAoB;IACpB,mBAAyB;IACzB,iBAAoB;IAEpB,iBAA8C;IAWhD;;;OAGG;IACH,eAKC;IAED,mDAIC;IAHC,cAAwB;IAK1B,uCAMC;IAED,6CAUC;IAED,yCA8DC;IAED,gDAiBC;CACF;8BA9J6B,2BAA2B;wBACjC,WAAW"}
+{"version":3,"file":"harvest-scheduler.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest-scheduler.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;;;;;SAUK;IACL,sBATa,MAAM;QAES,UAAU;QACV,UAAU;QACZ,UAAU,EAAvB,MAAM;QACQ,GAAG,EAAjB,OAAO;QACM,SAAS,EAAtB,MAAM;oBAoBlB;IAfC,iBAAwB;IACxB;;;oBARW,MAAM;aACN,OAAO;mBACP,MAAM;MAMK;IACtB,iBAAoB;IACpB,mBAAyB;IACzB,iBAAoB;IACpB,oBAAuB;IACvB,iBAA8C;IAWhD;;;OAGG;IACH,eAKC;IAED,mDAIC;IAHC,cAAwB;IAK1B,uCAMC;IAED,6CAUC;IAED,yCAgEC;IAED,gDAiBC;CACF;8BAhK6B,2BAA2B;wBACjC,WAAW"}

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":"AA8BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aA0EC;IAnEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAKzB,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;sBAvSqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AA8BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aA4EC;IAnEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAKzB,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;sBAzSqB,gBAAgB;iCAGL,4BAA4B"}

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

@@ -27,6 +27,8 @@ export class TimeKeeper {
      * @return {number} Corrected unix/epoch timestamp
      */
     correctAbsoluteTimestamp(timestamp: number): number;
+    /** Process the session entity and use the info to set the main time calculations if present */
+    processStoredDiff(): void;
     #private;
 }
 //# sourceMappingURL=time-keeper.d.ts.map

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":"AAKA;;;;GAIG;AACH;IA2BE,kCAaC;IAED,oBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAuBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;;CAoBF"}
+{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IA2BE,kCAGC;IAED,oBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAuBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;IAED,+FAA+F;IAC/F,0BAOC;;CACF"}

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

@@ -1,2 +1,3 @@
 export const FEATURE_NAME: string;
+export const MAX_PAYLOAD_SIZE: 1000000;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/ajax/constants.js"],"names":[],"mappings":"AAEA,kCAA8C"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/ajax/constants.js"],"names":[],"mappings":"AAEA,kCAA8C;AAE9C,uCAAuC"}

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,mEA6BC;IAxBG,2CAA0C;IAsB5C,yBAA+B;;CASlC;+BAlD8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IAIjC,mEA6BC;IAxBG,2CAA0C;IAsB5C,yBAA+B;;CASlC;+BAjD8B,6BAA6B"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAaA;IACE,2BAAiC;IACjC,mDAsBC;IAED,wDAKC;IAED,iDAKC;IAED,qBA6CC;IAED,0BAOC;IAED,eA0CC;IAvCG,mCAAyB;CAwC9B;8BA9I6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAaA;IACE,2BAAiC;IACjC,mDAsBC;IAED,wDAKC;IAED,iDAKC;IAED,qBA6CC;IAED,0BAOC;IAED,eAkCC;IA/BG,mCAAyB;CAgC9B;8BAtI6B,4BAA4B"}

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

@@ -4,7 +4,9 @@ export class Aggregate extends AggregateBase {
     timeToFirstByte: number;
     firstByteToWindowLoad: number;
     firstByteToDomContent: number;
+    timeKeeper: TimeKeeper;
     sendRum(): void;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
+import { TimeKeeper } from '../../../common/timing/time-keeper';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAA2C;IAC3C,mDAoBC;IAjBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAiBhC,gBAmGC;CACF;8BAvI6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAA2C;IAC3C,mDAqBC;IAlBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAC9B,uBAAsD;IAiBxD,gBAsGC;CACF;8BA3I6B,4BAA4B;2BAS/B,oCAAoC"}

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

@@ -27,7 +27,7 @@ export class Aggregate extends AggregateBase {
      * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
      * @returns {void}
      */
-    initializeRecording(errorSample: boolean, fullSample: boolean, ignoreSession: boolean): void;
+    initializeRecording(srMode: any, ignoreSession: boolean): void;
     prepUtils(): Promise<void>;
     prepareHarvest({ opts }?: {
         opts: 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":"AAgCA;IACE,2BAAiC;IAIjC,8DAiHC;IApHD,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,kBAA+C;IAoC/C,4BAKQ;IAuDV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA6DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAsEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BApZ6B,4BAA4B;iCAHzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAgCA;IACE,2BAAiC;IAIjC,8DAuGC;IA1GD,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,kBAA+C;IAoC/C,4BAKQ;IA6CV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,gDAHW,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAsEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BA3Y6B,4BAA4B;iCAHzB,2CAA2C"}

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

@@ -60,4 +60,7 @@ export namespace ABORT_REASONS {
 }
 /** Reserved room for query param attrs */
 export const QUERY_PARAM_PADDING: 5000;
+export namespace TRIGGERS {
+    let API: string;
+}
 //# sourceMappingURL=constants.d.ts.map

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

@@ -3,7 +3,6 @@ export class Instrument extends InstrumentBase {
     constructor(agentIdentifier: any, aggregator: any, auto?: boolean);
     replayRunning: boolean;
     errorNoticed: boolean;
-    recorder: import("../shared/recorder").Recorder | undefined;
     #private;
 }
 import { InstrumentBase } from '../../utils/instrument-base';

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":"AAiBA;IACE,2BAAiC;IACjC,mEA0BC;IAvBC,uBAA0B;IActB,sBAAwB;IA0B5B,4DAA0F;;CAK7F;+BAtD8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IAGjC,mEA+BC;IA5BC,uBAA0B;IAmBtB,sBAAwB;;CAgE/B;+BA9F8B,6BAA6B"}

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":"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,uBA+BC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAqDC;IA3CG,8BAAoB;IA6CxB,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BApN8B,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,uBAsCC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAqDC;IA3CG,8BAAoB;IA6CxB,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BA3N8B,mBAAmB"}

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

@@ -1,4 +1,4 @@
-export function enableSessionTracking(agentId: any): boolean;
+export function hasReplayPrerequisite(agentId: any): boolean;
 export function isPreloadAllowed(agentId: any): boolean;
 export function canImportReplayAgg(agentId: any, sessionMgr: any): boolean;
 export function buildNRMetaNode(timestamp: any, timeKeeper: any): {

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":"AAGA,6DAEC;AAQD,wDAEC;AAED,2EAGC;AAED;;;;;;;EAUC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAIA,6DAIC;AAED,wDAEC;AAED,2EAGC;AAED;;;;;;;EAUC"}