@newrelic/browser-agent 1.258.2 → 1.259.0

package/src/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/src/features/session_trace/aggregate/trace/storage.js

@@ -0,0 +1,287 @@
+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(([name, listOfSTNodes]) => { // 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, `${protocol}://${hostname}:${port}${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, `${params.status} ${params.method}: ${params.host}${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/src/features/session_trace/constants.js

@@ -8,3 +8,4 @@ export const END = '-end'
 export const FN_START = 'fn' + START
 export const FN_END = 'fn' + END
 export const PUSH_STATE = 'pushState'
+export const MAX_NODES_PER_HARVEST = 1000

package/src/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 {
@@ -18,7 +19,11 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator, auto = 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)

package/src/features/utils/__mocks__/feature-gates.js

@@ -0,0 +1 @@
+export const canEnableSessionTracking = jest.fn()

package/src/features/utils/aggregate-base.js

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

package/src/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/src/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'
 
 /**
@@ -79,7 +80,7 @@ export class InstrumentBase extends FeatureBase {
     const importLater = async () => {
       let session
       try {
-        if (enableSessionTracking(this.agentIdentifier)) { // would require some setup before certain features start
+        if (canEnableSessionTracking(this.agentIdentifier)) { // would require some setup before certain features start
           const { setupAgentSession } = await import(/* webpackChunkName: "session-manager" */ './agent-session')
           session = setupAgentSession(this.agentIdentifier)
         }

package/src/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 (agentIdentifier = 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/src/loaders/api/api-methods.js

@@ -3,7 +3,7 @@ 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',
+  'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start',
   SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE
 ]
 

package/src/loaders/api/api.js

@@ -196,8 +196,8 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
     import(/* webpackChunkName: "async-api" */'./apiAsync').then(({ setAPI }) => {
       setAPI(agentIdentifier)
       drain(agentIdentifier, 'api')
-    }).catch(() => {
-      warn('Downloading runtime APIs failed...')
+    }).catch((err) => {
+      warn('Downloading runtime APIs failed...', err)
       instanceEE.abort()
     })
   }

package/src/loaders/configure/configure.js

@@ -52,6 +52,7 @@ export function configure (agent, opts = {}, loaderType, forceDrain) {
     ...(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)

package/dist/cjs/features/session_replay/shared/replay-mode.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSessionReplayMode = getSessionReplayMode;
-var _config = require("../../../common/config/config");
-var _nreum = require("../../../common/window/nreum");
-var _sharedChannel = require("../../../common/constants/shared-channel");
-var _constants = require("../../../common/session/constants");
-/**
- * Figure out if the Replay feature is running (what mode it's in).
- * IMPORTANT: Session tracking is assumed to be ON; if applicable, check init's privacy.cookies_enabled setting before using this fn!
- * CRITICAL: This fn must be called prior to ALL features aggregate draining. If not, it will never resolve.
- * @param {String} agentId
- * @returns Promise that resolves to one of the values in MODE enum
- */
-async function getSessionReplayMode(agentId) {
-  try {
-    const newrelic = (0, _nreum.gosNREUM)();
-    // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
-    if ((0, _config.getConfigurationValue)(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
-      const srInitialized = await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported;
-      if (srInitialized) return await _sharedChannel.sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
-    }
-  } catch (e) {/* exception ==> off */}
-  return _constants.MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off
-}

package/dist/cjs/features/utils/handler-cache.js

@@ -1,70 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.HandlerCache = void 0;
-/**
- * A class to defer callback execution until a decision can be reached
- */
-class HandlerCache {
-  /** @private @type {boolean | undefined} */
-  #decision = undefined;
-  /** @private @type {Function[]} */
-  #cache = [];
-  /** @private @type {Timeout} */
-  #settleTimer = setTimeout(() => this.#close(), 5000);
-  #noMoreChanges = false;
-
-  /**
-   * tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-   * and execute all the storage callbacks saved up in the handlerCache
-   * @private
-   */
-  #drain() {
-    this.#cache.forEach(h => h());
-    this.#close();
-  }
-
-  /**
-   * tell the handlerCache not to execute any of the storage callbacks
-   * and wipe out all the storage callbacks saved up in the handlerCache
-   * @private
-   */
-  #close() {
-    this.#cache = [];
-    clearTimeout(this.#settleTimer);
-  }
-
-  /**
-   * Wrap callback functions with this method to defer their execution until a decision has been reached
-   * @param {Function} handler
-   * @returns {void}
-   */
-  settle(handler) {
-    if (this.#decision === false) {
-      // Do nothing
-    } else if (this.#decision === undefined) this.#cache.push(handler);else handler();
-  }
-
-  /**
-   * Make a decision about what to do with the cache of callbacks.
-   * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-   * and execute all the storage callbacks saved up in the handlerCache ---
-   * --- if false: tell the handlerCache not to execute any of the storage callbacks
-   * and wipe out all the storage callbacks saved up in the handlerCache
-   * @param {boolean} decision
-   */
-  decide(decision) {
-    if (this.#noMoreChanges) return;
-    this.#decision = decision;
-    if (decision === false) this.#close();
-    if (decision === true) this.#drain();
-  }
-  permanentlyDecide(decision) {
-    if (this.#noMoreChanges) return;
-    this.decide(decision);
-    this.#noMoreChanges = true;
-  }
-}
-exports.HandlerCache = HandlerCache;

package/dist/esm/features/session_replay/shared/replay-mode.js

@@ -1,23 +0,0 @@
-import { getConfigurationValue } from '../../../common/config/config';
-import { gosNREUM } from '../../../common/window/nreum';
-import { sharedChannel } from '../../../common/constants/shared-channel';
-import { MODE } from '../../../common/session/constants';
-
-/**
- * Figure out if the Replay feature is running (what mode it's in).
- * IMPORTANT: Session tracking is assumed to be ON; if applicable, check init's privacy.cookies_enabled setting before using this fn!
- * CRITICAL: This fn must be called prior to ALL features aggregate draining. If not, it will never resolve.
- * @param {String} agentId
- * @returns Promise that resolves to one of the values in MODE enum
- */
-export async function getSessionReplayMode(agentId) {
-  try {
-    const newrelic = gosNREUM();
-    // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
-    if (getConfigurationValue(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
-      const srInitialized = await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported;
-      if (srInitialized) return await sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
-    }
-  } catch (e) {/* exception ==> off */}
-  return MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off
-}

package/dist/esm/features/utils/handler-cache.js

@@ -1,63 +0,0 @@
-/**
- * A class to defer callback execution until a decision can be reached
- */
-export class HandlerCache {
-  /** @private @type {boolean | undefined} */
-  #decision = undefined;
-  /** @private @type {Function[]} */
-  #cache = [];
-  /** @private @type {Timeout} */
-  #settleTimer = setTimeout(() => this.#close(), 5000);
-  #noMoreChanges = false;
-
-  /**
-   * tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-   * and execute all the storage callbacks saved up in the handlerCache
-   * @private
-   */
-  #drain() {
-    this.#cache.forEach(h => h());
-    this.#close();
-  }
-
-  /**
-   * tell the handlerCache not to execute any of the storage callbacks
-   * and wipe out all the storage callbacks saved up in the handlerCache
-   * @private
-   */
-  #close() {
-    this.#cache = [];
-    clearTimeout(this.#settleTimer);
-  }
-
-  /**
-   * Wrap callback functions with this method to defer their execution until a decision has been reached
-   * @param {Function} handler
-   * @returns {void}
-   */
-  settle(handler) {
-    if (this.#decision === false) {
-      // Do nothing
-    } else if (this.#decision === undefined) this.#cache.push(handler);else handler();
-  }
-
-  /**
-   * Make a decision about what to do with the cache of callbacks.
-   * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-   * and execute all the storage callbacks saved up in the handlerCache ---
-   * --- if false: tell the handlerCache not to execute any of the storage callbacks
-   * and wipe out all the storage callbacks saved up in the handlerCache
-   * @param {boolean} decision
-   */
-  decide(decision) {
-    if (this.#noMoreChanges) return;
-    this.#decision = decision;
-    if (decision === false) this.#close();
-    if (decision === true) this.#drain();
-  }
-  permanentlyDecide(decision) {
-    if (this.#noMoreChanges) return;
-    this.decide(decision);
-    this.#noMoreChanges = true;
-  }
-}

package/dist/types/features/session_replay/shared/replay-mode.d.ts

@@ -1,9 +0,0 @@
-/**
- * Figure out if the Replay feature is running (what mode it's in).
- * IMPORTANT: Session tracking is assumed to be ON; if applicable, check init's privacy.cookies_enabled setting before using this fn!
- * CRITICAL: This fn must be called prior to ALL features aggregate draining. If not, it will never resolve.
- * @param {String} agentId
- * @returns Promise that resolves to one of the values in MODE enum
- */
-export function getSessionReplayMode(agentId: string): Promise<any>;
-//# sourceMappingURL=replay-mode.d.ts.map

package/dist/types/features/session_replay/shared/replay-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay-mode.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/replay-mode.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,oEAUC"}

package/dist/types/features/utils/handler-cache.d.ts

@@ -1,23 +0,0 @@
-/**
- * A class to defer callback execution until a decision can be reached
- */
-export class HandlerCache {
-    /**
-     * Wrap callback functions with this method to defer their execution until a decision has been reached
-     * @param {Function} handler
-     * @returns {void}
-     */
-    settle(handler: Function): void;
-    /**
-     * Make a decision about what to do with the cache of callbacks.
-     * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
-     * and execute all the storage callbacks saved up in the handlerCache ---
-     * --- if false: tell the handlerCache not to execute any of the storage callbacks
-     * and wipe out all the storage callbacks saved up in the handlerCache
-     * @param {boolean} decision
-     */
-    decide(decision: boolean): void;
-    permanentlyDecide(decision: any): void;
-    #private;
-}
-//# sourceMappingURL=handler-cache.d.ts.map

package/dist/types/features/utils/handler-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler-cache.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/handler-cache.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IA6BE;;;;OAIG;IACH,2BAFa,IAAI,CAOhB;IAED;;;;;;;OAOG;IACH,iBAFW,OAAO,QAOjB;IAED,uCAIC;;CACF"}