@newrelic/browser-agent 1.260.0 → 1.261.0

package/dist/esm/common/config/state/init.js

@@ -1,3 +1,4 @@
+import { LOG_LEVELS } from '../../../features/logging/constants';
 import { isValidSelector } from '../../dom/query-selector';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../../session/constants';
 import { warn } from '../../util/console';
@@ -29,16 +30,6 @@ const model = () => {
     }
   };
   return {
-    feature_flags: [],
-    proxy: {
-      assets: undefined,
-      // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
-      beacon: undefined // likewise for the url to which we send analytics
-    },
-    privacy: {
-      cookies_enabled: true
-    },
-    // *cli - per discussion, default should be true
     ajax: {
       deny_list: undefined,
       block_internal: true,
@@ -53,21 +44,26 @@ const model = () => {
       cors_use_tracecontext_headers: undefined,
       allowed_origins: undefined
     },
-    session: {
-      expiresMs: DEFAULT_EXPIRES_MS,
-      inactiveMs: DEFAULT_INACTIVE_MS
+    feature_flags: [],
+    harvest: {
+      tooManyRequestsDelay: 60
     },
-    ssl: undefined,
-    obfuscate: undefined,
     jserrors: {
       enabled: true,
       harvestTimeSeconds: 10,
       autoStart: true
     },
+    logging: {
+      enabled: true,
+      harvestTimeSeconds: 10,
+      autoStart: true,
+      level: LOG_LEVELS.INFO
+    },
     metrics: {
       enabled: true,
       autoStart: true
     },
+    obfuscate: undefined,
     page_action: {
       enabled: true,
       harvestTimeSeconds: 30,
@@ -83,13 +79,18 @@ const model = () => {
       long_task: false,
       autoStart: true
     },
-    session_trace: {
-      enabled: true,
-      harvestTimeSeconds: 10,
-      autoStart: true
+    privacy: {
+      cookies_enabled: true
     },
-    harvest: {
-      tooManyRequestsDelay: 60
+    // *cli - per discussion, default should be true
+    proxy: {
+      assets: undefined,
+      // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
+      beacon: undefined // likewise for the url to which we send analytics
+    },
+    session: {
+      expiresMs: DEFAULT_EXPIRES_MS,
+      inactiveMs: DEFAULT_INACTIVE_MS
     },
     session_replay: {
       // feature settings
@@ -146,7 +147,7 @@ const model = () => {
         };else warn('An invalid session_replay.mask_input_option was provided and will not be used', val);
       }
     },
-    spa: {
+    session_trace: {
       enabled: true,
       harvestTimeSeconds: 10,
       autoStart: true
@@ -155,7 +156,13 @@ const model = () => {
       enabled: true,
       harvestTimeSeconds: 10,
       autoStart: true
-    }
+    },
+    spa: {
+      enabled: true,
+      harvestTimeSeconds: 10,
+      autoStart: true
+    },
+    ssl: undefined
   };
 };
 const _cache = {};

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.260.0";
+export const VERSION = "1.261.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.260.0";
+export const VERSION = "1.261.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/runtime.js

@@ -5,6 +5,8 @@
  * @license Apache-2.0
  */
 
+import { now } from '../timing/now';
+
 /**
  * Indicates if the agent is running within a normal browser window context.
  */
@@ -44,4 +46,4 @@ export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon;
  * according to the browser's local clock.
  * @type {number}
  */
-export const originTime = Math.floor(Date.now() - performance.now());
+export const originTime = Date.now() - now();

package/dist/esm/common/deny-list/deny-list.js

@@ -10,7 +10,7 @@ var denyList = [];
  * @returns {boolean} `true` if request does not match any entries of {@link denyList|deny list}; else `false`
  */
 export function shouldCollectEvent(params) {
-  if (hasUndefinedHostname(params)) return false;
+  if (!params || hasUndefinedHostname(params)) return false;
   if (denyList.length === 0) return true;
   for (var i = 0; i < denyList.length; i++) {
     var parsed = denyList[i];

package/dist/esm/common/session/session-entity.js

@@ -3,7 +3,7 @@ import { warn } from '../util/console';
 import { stringify } from '../util/stringify';
 import { ee } from '../event-emitter/contextual-ee';
 import { Timer } from '../timer/timer';
-import { isBrowserScope } from '../constants/runtime';
+import { isBrowserScope, isIE } from '../constants/runtime';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, MODE, PREFIX, SESSION_EVENTS, SESSION_EVENT_TYPES } from './constants';
 import { InteractionTimer } from '../timer/interaction-timer';
 import { wrapEvents } from '../wrap';
@@ -53,7 +53,13 @@ export class SessionEntity {
     this.ee = ee.get(agentIdentifier);
     wrapEvents(this.ee);
     this.setup(opts);
-    if (isBrowserScope) {
+
+    /**
+     * Do not emit session storage events for IE11, because IE11 is unable to determine
+     * if the event was spawned on the current page or an adjacent page, and the behavior tied
+     * to storage events is critical to apply only to cross-tab behavior
+     * */
+    if (isBrowserScope && !isIE) {
       windowAddEventListener('storage', event => {
         if (event.key === this.lookupKey) {
           const obj = typeof event.newValue === 'string' ? JSON.parse(event.newValue) : event.newValue;

package/dist/esm/common/timing/time-keeper.js

@@ -57,7 +57,7 @@ export class TimeKeeper {
       throw new Error('Missing date header on rum response.');
     }
     const medianRumOffset = (endTime - startTime) / 2;
-    const serverOffset = Math.floor(startTime + medianRumOffset);
+    const serverOffset = startTime + medianRumOffset;
 
     // Corrected page origin time
     this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
@@ -78,7 +78,7 @@ export class TimeKeeper {
    * @returns {number} Corrected unix/epoch timestamp
    */
   convertRelativeTimestamp(relativeTime) {
-    return this.#correctedOriginTime + relativeTime;
+    return Math.floor(this.#correctedOriginTime + relativeTime);
   }
 
   /**

package/dist/esm/common/wrap/wrap-logger.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps native timeout and interval methods for instrumentation.
+ * This module is used by: jserrors, spa.
+ */
+
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
+import { EventContext } from '../event-emitter/event-context';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
+
+/**
+ * Wraps a supplied function and adds emitter events under the `-wrap-logger-` prefix
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @param {Object} parent - The parent object housing the logger function
+ * @param {string} loggerFn - The name of the function in the parent object to wrap
+ * @returns {Object} Scoped event emitter with a debug ID of `logger`.
+ */
+// eslint-disable-next-line
+export function wrapLogger(sharedEE, parent, loggerFn, context) {
+  const ee = scopedEE(sharedEE);
+  const wrapFn = wfn(ee);
+
+  /**
+   * This section contains the context that will be shared across all invoked calls of the wrapped function,
+   * which will be used to decorate the log data later at agg time
+  */
+  const ctx = new EventContext(contextId);
+  ctx.level = context.level;
+  ctx.customAttributes = context.customAttributes;
+
+  /** observe calls to <loggerFn> and emit events prefixed with `wrap-logger-` */
+  wrapFn.inPlace(parent, [loggerFn], 'wrap-logger-', ctx);
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `logger` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *     Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'logger'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('logger');
+}

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

@@ -0,0 +1,95 @@
+import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { handle } from '../../../common/event-emitter/handle';
+import { registerHandler } from '../../../common/event-emitter/register-handler';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
+import { warn } from '../../../common/util/console';
+import { stringify } from '../../../common/util/stringify';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
+import { AggregateBase } from '../../utils/aggregate-base';
+import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOGGING_IGNORED, MAX_PAYLOAD_SIZE } from '../constants';
+import { Log } from '../shared/log';
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME;
+  #agentRuntime;
+  #agentInfo;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME);
+
+    /** held logs before sending */
+    this.bufferedLogs = [];
+    /** held logs during sending, for retries */
+    this.outgoingLogs = [];
+    /** the estimated bytes of log data waiting to be sent -- triggers a harvest if adding a new log will exceed limit  */
+    this.estimatedBytes = 0;
+    this.#agentRuntime = getRuntime(this.agentIdentifier);
+    this.#agentInfo = getInfo(this.agentIdentifier);
+    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'logging.harvestTimeSeconds');
+    this.waitForFlags([]).then(() => {
+      this.scheduler = new HarvestScheduler('browser/logs', {
+        onFinished: this.onHarvestFinished.bind(this),
+        retryDelay: this.harvestTimeSeconds,
+        getPayload: this.prepareHarvest.bind(this),
+        raw: true
+      }, this);
+      /** harvest immediately once started to purge pre-load logs collected */
+      this.scheduler.startTimer(this.harvestTimeSeconds, 0);
+      /** emitted by instrument class (wrapped loggers) or the api methods directly */
+      registerHandler(LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee);
+      this.drain();
+    });
+  }
+  handleLog(timestamp, message, attributes, level) {
+    if (this.blocked) return;
+    const log = new Log(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp), message, attributes, level);
+    const logBytes = log.message.length + stringify(log.attributes).length + log.level.length + 10; // timestamp == 10 chars
+    if (logBytes > MAX_PAYLOAD_SIZE) {
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes]);
+      return warn(LOGGING_IGNORED + '> ' + MAX_PAYLOAD_SIZE + ' bytes', log.message.slice(0, 25) + '...');
+    }
+    if (this.estimatedBytes + logBytes >= MAX_PAYLOAD_SIZE) {
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.estimatedBytes + logBytes]);
+      this.scheduler.runHarvest({});
+    }
+    this.estimatedBytes += logBytes;
+    this.bufferedLogs.push(log);
+  }
+  prepareHarvest() {
+    if (this.blocked || !(this.bufferedLogs.length || this.outgoingLogs.length)) return;
+    /** populate outgoing array while also clearing main buffer */
+    this.outgoingLogs.push(...this.bufferedLogs.splice(0));
+    this.estimatedBytes = 0;
+    /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
+    return {
+      qs: {
+        browser_monitoring_key: this.#agentInfo.licenseKey
+      },
+      body: [{
+        common: {
+          /** Attributes in the `common` section are added to `all` logs generated in the payload */
+          attributes: {
+            'entity.guid': this.#agentRuntime.appMetadata?.agents?.[0]?.entityGuid,
+            // browser entity guid as provided from RUM response
+            session: this.#agentRuntime?.session?.state.value || '0',
+            // The session ID that we generate and keep across page loads
+            hasReplay: this.#agentRuntime?.session?.state.sessionReplayMode === 1,
+            // True if a session replay recording is running
+            hasTrace: this.#agentRuntime?.session?.state.sessionTraceMode === 1,
+            // True if a session trace recording is running
+            ptid: this.#agentRuntime.ptid,
+            // page trace id
+            appId: this.#agentInfo.applicationID,
+            // Application ID from info object,
+            standalone: Boolean(this.#agentInfo.sa),
+            // copy paste (true) vs APM (false)
+            agentVersion: this.#agentRuntime.version // browser agent version
+          }
+        },
+        /** logs section contains individual unique log entries */
+        logs: this.outgoingLogs
+      }]
+    };
+  }
+  onHarvestFinished(result) {
+    if (!result.retry) this.outgoingLogs = [];
+  }
+}

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

@@ -0,0 +1,14 @@
+import { FEATURE_NAMES } from '../../loaders/features/features';
+export const LOG_LEVELS = {
+  ERROR: 'ERROR',
+  WARN: 'WARN',
+  INFO: 'INFO',
+  DEBUG: 'DEBUG',
+  TRACE: 'TRACE'
+};
+export const LOGGING_EVENT_EMITTER_CHANNEL = 'log';
+export const FEATURE_NAME = FEATURE_NAMES.logging;
+export const MAX_PAYLOAD_SIZE = 1000000;
+export const LOGGING_FAILURE_MESSAGE = 'failed to wrap logger: ';
+export const LOGGING_LEVEL_FAILURE_MESSAGE = 'invalid log level: ';
+export const LOGGING_IGNORED = 'ignored log: ';

package/dist/esm/features/logging/index.js

@@ -0,0 +1 @@
+export { Instrument as Logging } from './instrument/index';

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

@@ -0,0 +1,21 @@
+import { InstrumentBase } from '../../utils/instrument-base';
+import { FEATURE_NAME } from '../constants';
+import { bufferLog } from '../shared/utils';
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    const instanceEE = this.ee;
+    /** emitted by wrap-logger function */
+    this.ee.on('wrap-logger-end', function handleLog(_ref) {
+      let [message] = _ref;
+      const {
+        level,
+        customAttributes
+      } = this;
+      bufferLog(instanceEE, message, customAttributes, level);
+    });
+    this.importAggregator();
+  }
+}

package/dist/esm/features/logging/shared/log.js

@@ -0,0 +1,32 @@
+import { globalScope } from '../../../common/constants/runtime';
+import { cleanURL } from '../../../common/url/clean-url';
+import { LOG_LEVELS } from '../constants';
+export class Log {
+  /** @type {long} the unix timestamp of the log event */
+  timestamp;
+  /** @type {string} the log message */
+  message;
+  /** @type {object} the object of attributes to be parsed by logging ingest into top-level properties */
+  attributes;
+  /** @type {'ERROR'|'TRACE'|'DEBUG'|'INFO'|'WARN'} the log type of the log */
+  level;
+
+  /**
+   * @param {number} timestamp - Unix timestamp
+   * @param {string} message - message string
+   * @param {object} attributes - other log event attributes
+   * @param {enum} level - Log level
+   */
+  constructor(timestamp, message) {
+    let attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let level = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : LOG_LEVELS.INFO;
+    /** @type {long} */
+    this.timestamp = timestamp;
+    this.message = message;
+    this.attributes = {
+      ...attributes,
+      pageUrl: cleanURL('' + globalScope.location)
+    };
+    this.level = level.toUpperCase();
+  }
+}

package/dist/esm/features/logging/shared/utils.js

@@ -0,0 +1,44 @@
+import { handle } from '../../../common/event-emitter/handle';
+import { now } from '../../../common/timing/now';
+import { warn } from '../../../common/util/console';
+import { stringify } from '../../../common/util/stringify';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
+import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
+
+/**
+   * @param {ContextualEE} ee - The contextual ee tied to the instance
+   * @param {string} message - the log message string
+   * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
+   * @param {enum} level - the log level enum
+   */
+export function bufferLog(ee, message) {
+  let customAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let level = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : LOG_LEVELS.INFO;
+  try {
+    if (typeof message !== 'string') {
+      const stringified = stringify(message);
+      /**
+       * Error instances convert to `{}` when stringified
+       * Symbol converts to '' when stringified
+       * other cases tbd
+       * */
+      if (!!stringified && stringified !== '{}') message = stringified;else message = String(message);
+    }
+  } catch (err) {
+    warn('could not cast log message to string', message);
+    return;
+  }
+  handle(SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, FEATURE_NAMES.metrics, ee);
+  handle(LOGGING_EVENT_EMITTER_CHANNEL, [now(), message, customAttributes, level], undefined, FEATURE_NAMES.logging, ee);
+}
+
+/**
+ * Checks if a supplied log level is acceptable for use in generating a log event
+ * @param {string} level
+ * @returns {boolean}
+ */
+export function isValidLogLevel(level) {
+  if (typeof level !== 'string') return false;
+  return Object.values(LOG_LEVELS).some(logLevel => logLevel.toUpperCase() === level.toUpperCase());
+}

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

@@ -42,7 +42,6 @@ export class Aggregate extends AggregateBase {
     if (getConfigurationValue(this.agentIdentifier, 'page_view_timing.long_task') === true) longTask.subscribe(this.#handleVitalMetric);
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee);
     registerHandler('winPagehide', msTimestamp => this.recordPageUnload(msTimestamp), this.featureName, this.ee);
-    const initialHarvestSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.initialHarvestSeconds') || 10;
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.harvestTimeSeconds') || 30;
     this.waitForFlags([]).then(() => {
       /* It's important that CWV api, like "onLCP", is called before the **scheduler** is initialized. The reason is because they listen to the same
@@ -79,7 +78,7 @@ export class Aggregate extends AggregateBase {
           return _this.prepareHarvest(...arguments);
         }
       }, this);
-      scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
+      scheduler.startTimer(harvestTimeSeconds);
       this.drain();
     });
   }

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

@@ -298,7 +298,7 @@ export class Aggregate extends AggregateBase {
       this.scheduler.opts.gzip = false;
     }
     if (len > MAX_PAYLOAD_SIZE) {
-      this.abort(ABORT_REASONS.TOO_BIG);
+      this.abort(ABORT_REASONS.TOO_BIG, len);
       return;
     }
     // TODO -- Gracefully handle the buffer for retries.
@@ -415,8 +415,9 @@ export class Aggregate extends AggregateBase {
   /** Abort the feature, once aborted it will not resume */
   abort() {
     let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let data = arguments.length > 1 ? arguments[1] : undefined;
     warn("SR aborted -- ".concat(reason.message));
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ["SessionReplay/Abort/".concat(reason.sm)], undefined, FEATURE_NAMES.metrics, this.ee);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ["SessionReplay/Abort/".concat(reason.sm), data], undefined, FEATURE_NAMES.metrics, this.ee);
     this.blocked = true;
     this.mode = MODE.OFF;
     this.recorder?.stopRecording?.();

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

@@ -42,22 +42,30 @@ export class Aggregate extends AggregateBase {
     this.entitled ??= stEntitled;
     if (this.blocked || !this.entitled) return deregisterDrain(this.agentIdentifier, this.featureName);
     if (!this.initialized) {
+      this.initialized = true;
+      /** Store session identifiers at initialization time to be cross-checked later at harvest time for session changes that are subject to race conditions */
+      this.ptid = this.agentRuntime.ptid;
+      this.sessionId = this.agentRuntime.session?.state.value;
       // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
       this.ee.on(SESSION_EVENTS.RESET, () => {
-        this.abort();
+        if (this.blocked) return;
+        this.abort(1);
       });
       // The SessionEntity can have updates (locally or across tabs for SR mode changes), (across tabs for ST mode changes).
       // Those updates should be sync'd here to ensure this page also honors the mode after initialization
       this.ee.on(SESSION_EVENTS.UPDATE, (eventType, sessionState) => {
+        if (this.blocked) return;
         // this will only have an effect if ST is NOT already in full mode
         if (this.mode !== MODE.FULL && (sessionState.sessionReplayMode === MODE.FULL || sessionState.sessionTraceMode === MODE.FULL)) this.switchToFull();
+        // if another page's session entity has expired, or another page has transitioned to off and this one hasn't... we can just abort straight away here
+        if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === MODE.OFF) this.abort(2);
       });
     }
 
     /** ST/SR sampling flow in BCS - https://drive.google.com/file/d/19hwt2oft-8Hh4RrjpLqEXfpP_9wYBLcq/view?usp=sharing */
     /** ST will run in the mode provided by BCS if the session IS NEW.  If not... it will use the state of the session entity to determine what mode to run in */
     if (!this.agentRuntime.session.isNew && !ignoreSession) this.mode = this.agentRuntime.session.state.sessionTraceMode;else this.mode = stMode;
-    this.initialized = true;
+
     /** If the mode is off, we do not want to hold up draining for other features, so we deregister the feature for now.
      * If it drains later (due to a mode change), data and handlers will instantly drain instead of waiting for the registry. */
     if (this.mode === MODE.OFF) return deregisterDrain(this.agentIdentifier, this.featureName);
@@ -122,15 +130,15 @@ export class Aggregate extends AggregateBase {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.traceStorage.prevStoredEvents.clear(); // release references to past events for GC
     if (!this.timeKeeper?.ready) return; // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
-    if (this.mode === MODE.OFF && this.traceStorage.nodeCount === 0) return;
-    if (this.mode === MODE.ERROR) return; // Trace in this mode should never be harvesting, even on unload
-
+    if (this.blocked || this.mode !== MODE.FULL || this.traceStorage.nodeCount === 0) return;
+    if (this.sessionId !== this.agentRuntime.session?.state.value || this.ptid !== this.agentRuntime.ptid) return this.abort(3); // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
     /** Get the ST nodes from the traceStorage buffer.  This also returns helpful metadata about the payload. */
     const {
       stns,
       earliestTimeStamp,
       latestTimeStamp
     } = this.traceStorage.takeSTNs();
+    if (!stns) return; // there are no trace nodes
     if (options.retry) {
       this.sentTrace = stns;
     }
@@ -179,8 +187,8 @@ export class Aggregate extends AggregateBase {
           ...(hasReplay && {
             hasReplay
           }),
-          ptid: "".concat(this.agentRuntime.ptid),
-          session: "".concat(this.agentRuntime.session?.state.value),
+          ptid: "".concat(this.ptid),
+          session: "".concat(this.sessionId),
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && {
             'enduser.id': endUserId
@@ -222,7 +230,7 @@ export class Aggregate extends AggregateBase {
   }
 
   /** Stop running for the remainder of the page lifecycle */
-  abort() {
+  abort(reason) {
     this.blocked = true;
     this.mode = MODE.OFF;
     this.agentRuntime.session.write({

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

@@ -272,7 +272,7 @@ export class TraceStorage {
   // 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)));
+    this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, "".concat(params.status, " ").concat(params.method, ": ").concat(params.host).concat(params.pathname), 'ajax'));
   }
   restoreNode(name, listOfSTNodes) {
     if (this.nodeCount >= MAX_NODES_PER_HARVEST) return;

package/dist/esm/features/soft_navigations/aggregate/bel-node.js

@@ -1,10 +1,9 @@
-import { now } from '../../../common/timing/now';
 let nodesSeen = 0;
 export class BelNode {
   belType;
   /** List of other BelNode derivatives. Each children should be of a subclass that implements its own 'serialize' function. */
   children = [];
-  start = now();
+  start;
   end;
   callbackEnd = 0;
   callbackDuration = 0;

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

@@ -61,7 +61,7 @@ export class Aggregate extends AggregateBase {
     });
 
     // By default, a complete UI driven interaction requires event -> URL change -> DOM mod in that exact order.
-    registerHandler('newUIEvent', event => this.startUIInteraction(event.type, event.timeStamp, event.target), this.featureName, this.ee);
+    registerHandler('newUIEvent', event => this.startUIInteraction(event.type, Math.floor(event.timeStamp), event.target), this.featureName, this.ee);
     registerHandler('newURL', (timestamp, url) => this.interactionInProgress?.updateHistory(timestamp, url), this.featureName, this.ee);
     registerHandler('newDom', timestamp => {
       this.interactionInProgress?.updateDom(timestamp);

package/dist/esm/features/soft_navigations/aggregate/interaction.js

@@ -2,6 +2,7 @@ import { getInfo } from '../../../common/config/config';
 import { globalScope, initialLocation } from '../../../common/constants/runtime';
 import { generateUuid } from '../../../common/ids/unique-id';
 import { addCustomAttributes, getAddStringContext, nullable, numeric } from '../../../common/serialize/bel-serializer';
+import { now } from '../../../common/timing/now';
 import { cleanURL } from '../../../common/url/clean-url';
 import { NODE_TYPE, INTERACTION_STATUS, INTERACTION_TYPE, API_TRIGGER_NAME } from '../constants';
 import { BelNode } from './bel-node';
@@ -39,11 +40,11 @@ export class Interaction extends BelNode {
     if (this.trigger === API_TRIGGER_NAME) this.createdByApi = true;
   }
   updateDom(timestamp) {
-    this.domTimestamp = timestamp || performance.now(); // default timestamp should be precise for accurate isActiveDuring calculations
+    this.domTimestamp = timestamp || now(); // default timestamp should be precise for accurate isActiveDuring calculations
   }
   updateHistory(timestamp, newUrl) {
     this.newURL = newUrl || '' + globalScope?.location;
-    this.historyTimestamp = timestamp || performance.now();
+    this.historyTimestamp = timestamp || now();
   }
   seenHistoryAndDomChange() {
     return this.historyTimestamp > 0 && this.domTimestamp > this.historyTimestamp; // URL must change before DOM does
@@ -113,9 +114,9 @@ export class Interaction extends BelNode {
     // IMPORTANT: The order in which addString is called matters and correlates to the order in which string shows up in the harvest payload. Do not re-order the following code.
     const fields = [numeric(this.belType), 0,
     // this will be overwritten below with number of attached nodes
-    numeric(Math.floor(this.start - firstStartTimeOfPayload)),
+    numeric(this.start - firstStartTimeOfPayload),
     // relative to first node
-    numeric(Math.floor(this.end - this.start)),
+    numeric(this.end - this.start),
     // end -- relative to start
     numeric(this.callbackEnd),
     // cbEnd -- relative to start; not used by BrowserInteraction events

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

@@ -536,7 +536,7 @@ export class Aggregate extends AggregateBase {
       var interaction = this.ixn;
       var node = activeNodeFor(interaction);
       setCurrentNode(null);
-      node.child('customEnd', timestamp).finish(timestamp);
+      node.child('customEnd', timestamp)?.finish(timestamp);
       interaction.finish();
     }, this.featureName, baseEE);
     register(INTERACTION_API + 'ignore', function (t) {

package/dist/esm/features/utils/lazy-feature-loader.js

@@ -18,6 +18,8 @@ export function lazyFeatureLoader(featureName, featurePart) {
         return import( /* webpackChunkName: "ajax-aggregate" */'../ajax/aggregate');
       case FEATURE_NAMES.jserrors:
         return import( /* webpackChunkName: "jserrors-aggregate" */'../jserrors/aggregate');
+      case FEATURE_NAMES.logging:
+        return import( /* webpackChunkName: "logging-aggregate" */'../logging/aggregate');
       case FEATURE_NAMES.metrics:
         return import( /* webpackChunkName: "metrics-aggregate" */'../metrics/aggregate');
       case FEATURE_NAMES.pageAction: