@newrelic/browser-agent 1.258.2 → 1.259.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/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/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;;;MAwBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FA4FC;IA4BD,yDA6BC;IAED,qFAOC;;CAwBF;wBAvSY,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,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IA0B1B;;;MAwBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FA6FC;IA4BD,yDA6BC;IAED,qFAOC;;CAwBF;wBAxSY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}

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/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/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"}

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

@@ -1,61 +1,48 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
-    constructor(agentIdentifier: any, aggregator: any, argsObj: any);
+    constructor(agentIdentifier: any, aggregator: any);
     agentRuntime: any;
-    resourceObserver: any;
-    ptid: string;
-    trace: {};
-    nodeCount: number;
-    sentTrace: {} | null;
-    prevStoredEvents: Set<any>;
+    agentInfo: any;
+    /** A buffer to hold on to harvested traces in the case that a retry must be made later */
+    sentTrace: any[] | null | undefined;
     harvestTimeSeconds: any;
-    maxNodesPerHarvest: any;
-    /**
-     * Standalone (mode) refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
-     * It has some different behavior vs when used in tandem with replay. */
-    isStandalone: boolean;
-    operationalGate: HandlerCache;
-    startTracing(startupBuffer: any, dontStartHarvestYet?: boolean): void;
-    processPVT(name: any, value: any, attrs: any): void;
-    storeTiming(timingEntry: any): void;
-    storeEvent(currentEvent: any, target: any, start: any, end: any): void;
-    shouldIgnoreEvent(event: any, target: any): boolean;
-    evtName(type: any): any;
-    evtOrigin(t: any, target: any): string;
-    storeHist(path: any, old: any, time: any): void;
-    storeResources(resources: any): void;
-    storeErrorAgg(type: any, name: any, params: any, metrics: any): void;
-    storeXhrAgg(type: any, name: any, params: any, metrics: any): void;
-    storeSTN(stn: any): void;
-    /**
-     * 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: number): number;
-    takeSTNs(retry: any): {
-        qs?: undefined;
-        body?: undefined;
-    } | {
+    /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
+    entitled: any;
+    /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
+    everHarvested: boolean;
+    /** If the harvest module is harvesting */
+    harvesting: boolean;
+    /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
+    traceStorage: TraceStorage;
+    /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
+    initialize(stMode: any, stEntitled: any, ignoreSession: any): void;
+    mode: any;
+    initialized: boolean | undefined;
+    scheduler: HarvestScheduler | undefined;
+    /** This module does not auto harvest by default -- it needs to be kicked off.  Once this method is called, it will then harvest on an interval */
+    startHarvesting(): void;
+    /** Called by the harvest scheduler at harvest time to retrieve the payload.  This will only actually return a payload if running in full mode */
+    prepareHarvest(options?: {}): {
         qs: {
-            fsh?: number | undefined;
-            st: number;
-            /** hr === "hasReplay" in NR1, standalone is always checked and processed before harvesting
-             * so a race condition between ST and SR states should not be a concern if implemented here */
-            hr: number;
-            /** fts === "firstTimestamp" in NR1, indicates what the earliest NODE timestamp was
-             * so that blob parsing doesn't need to happen to support UI/API functions  */
-            fts: number;
-            /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
-            n: number;
-        };
-        body: {
-            res: any[];
+            browser_monitoring_key: any;
+            type: string;
+            app_id: any;
+            protocol_version: string;
+            timestamp: any;
+            attributes: string;
         };
-    };
-    smearEvtsByOrigin(name: any): (byOrigin: any, evtNode: any) => any;
-    #private;
+        body: any[] | undefined;
+    } | undefined;
+    /** When the harvest scheduler finishes, this callback is executed. It's main purpose is to determine if the payload needs to be retried
+     * and if so, it will take all data from the temporary buffer and place it back into the traceStorage module
+     */
+    onHarvestFinished(result: any): void;
+    /** Switch from "off" or "error" to full mode (if entitled) */
+    switchToFull(): void;
+    /** Stop running for the remainder of the page lifecycle */
+    abort(): void;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
-import { HandlerCache } from '../../utils/handler-cache';
+import { TraceStorage } from './trace/storage';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAkCA;IACE,2BAAiC;IAGjC,iEAyIC;IAvIC,kBAA+C;IAC/C,sBAAiD;IACjD,aAAc;IACd,UAAe;IACf,kBAAkB;IAClB,qBAAqB;IACrB,2BAAiC;IACjC,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,sBAAyB;IAGzB,8BAAsC;IA0HxC,sEAcC;IA8CD,oDAOC;IAGD,oCAwBC;IAGD,uEAoBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BA/gB6B,4BAA4B;6BAF7B,2BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAAiC;IAEjC,mDAmBC;IAjBC,kBAA+C;IAC/C,eAAyC;IAEzC,0FAA0F;IAC1F,oCAAqB;IACrB,wBAA0G;IAC1G,0GAA0G;IAC1G,cAAyB;IACzB,mIAAmI;IACnI,uBAA0B;IAC1B,0CAA0C;IAC1C,oBAAuB;IACvB,wIAAwI;IACxI,2BAA0C;IAM5C,gLAAgL;IAChL,mEA6DC;IA1CyD,UAA4D;IAGpH,iCAAuB;IAOvB,wCAKQ;IA6BV,kJAAkJ;IAClJ,wBAIC;IAED,iJAAiJ;IACjJ;;;;;;;;;;kBA4DC;IAED;;OAEG;IACH,qCAKC;IAED,8DAA8D;IAC9D,qBAUC;IAED,2DAA2D;IAC3D,cAKC;CACF;8BAtM6B,4BAA4B;6BAC7B,iBAAiB;iCAJb,2CAA2C"}

package/dist/types/features/session_trace/aggregate/trace/node.d.ts

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

package/dist/types/features/session_trace/aggregate/trace/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../../src/features/session_trace/aggregate/trace/node.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IACE,qEAMC;IALC,OAAa;IACb,OAAc;IACd,OAAY;IACZ,OAAe;IACf,OAAa;CAEhB"}