@newrelic/browser-agent 1.264.0 → 1.265.0

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

@@ -11,7 +11,9 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { stringify } from '../../../common/util/stringify';
 import { handle } from '../../../common/event-emitter/handle';
-import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfigurationValue } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { globalScope } from '../../../common/constants/runtime';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
@@ -19,17 +21,16 @@ import { AggregateBase } from '../../utils/aggregate-base';
 import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { now } from '../../../common/timing/now';
+import { applyFnToProps } from '../../../common/util/traverse';
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
  */
 
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
-    var _this;
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    _this = this;
     this.stackReported = {};
     this.observedAt = {};
     this.pageviewReported = {};
@@ -39,28 +40,19 @@ export class Aggregate extends AggregateBase {
 
     // this will need to change to match whatever ee we use in the instrument
     this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved));
-    register('err', function () {
-      return _this.storeError(...arguments);
-    }, this.featureName, this.ee);
-    register('ierr', function () {
-      return _this.storeError(...arguments);
-    }, this.featureName, this.ee);
+    register('err', (...args) => this.storeError(...args), this.featureName, this.ee);
+    register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
 
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
 
     // 0 == off, 1 == on
-    this.waitForFlags(['err']).then(_ref => {
-      let [errFlag] = _ref;
+    this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
         const scheduler = new HarvestScheduler('jserrors', {
-          onFinished: function () {
-            return _this.onHarvestFinished(...arguments);
-          }
+          onFinished: (...args) => this.onHarvestFinished(...args)
         }, this);
-        scheduler.harvest.on('jserrors', function () {
-          return _this.onHarvestStarted(...arguments);
-        });
+        scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args));
         scheduler.startTimer(harvestTimeSeconds);
         this.drain();
       } else {
@@ -71,7 +63,7 @@ export class Aggregate extends AggregateBase {
   }
   onHarvestStarted(options) {
     // this gets rid of dependency in AJAX module
-    var body = this.aggregator.take(['err', 'ierr', 'xhr']);
+    var body = applyFnToProps(this.aggregator.take(['err', 'ierr', 'xhr']), this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
     if (options.retry) {
       this.currentBody = body;
     }
@@ -94,8 +86,7 @@ export class Aggregate extends AggregateBase {
   }
   onHarvestFinished(result) {
     if (result.retry && this.currentBody) {
-      Object.entries(this.currentBody || {}).forEach(_ref2 => {
-        let [key, value] = _ref2;
+      Object.entries(this.currentBody || {}).forEach(([key, value]) => {
         for (var i = 0; i < value.length; i++) {
           var bucket = value[i];
           var name = this.getBucketName(key, bucket.params, bucket.custom);
@@ -171,7 +162,7 @@ export class Aggregate extends AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = truncateSize(stackInfo.stackString);
-      this.observedAt[bucketHash] = agentRuntime.timeKeeper.convertRelativeTimestamp(time);
+      this.observedAt[bucketHash] = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(agentRuntime.timeKeeper.convertRelativeTimestamp(time)));
     } else {
       params.browser_stack_hash = stringHashCode(stackInfo.stackString);
     }
@@ -187,7 +178,7 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true;
     }
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash];
-    params.timestamp = agentRuntime.timeKeeper.convertRelativeTimestamp(time);
+    params.timestamp = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(agentRuntime.timeKeeper.convertRelativeTimestamp(time)));
     var type = internal ? 'ierr' : 'err';
     var newMetrics = {
       time
@@ -220,30 +211,20 @@ export class Aggregate extends AggregateBase {
       this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes);
     }
   }
-  #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished) {
-    let softNavCustomAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished, softNavCustomAttrs = {}) {
     let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr;
     const allCustomAttrs = {};
     if (softNavOccurredFinished) {
-      Object.entries(softNavCustomAttrs).forEach(_ref3 => {
-        let [k, v] = _ref3;
-        return setCustom(k, v);
-      }); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
+      Object.entries(softNavCustomAttrs).forEach(([k, v]) => setCustom(k, v)); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
       bucketHash += params.browserInteractionId;
       delete params._softNavAttributes; // cleanup temp properties from synchronous evaluation; this is harmless when async from soft nav (properties DNE)
       delete params._softNavFinished;
     } else {
       // interaction was cancelled -> error should not be associated OR there was no interaction
-      Object.entries(getInfo(this.agentIdentifier).jsAttributes).forEach(_ref4 => {
-        let [k, v] = _ref4;
-        return setCustom(k, v);
-      });
+      Object.entries(getInfo(this.agentIdentifier).jsAttributes).forEach(([k, v]) => setCustom(k, v));
       delete params.browserInteractionId;
     }
-    if (localAttrs) Object.entries(localAttrs).forEach(_ref5 => {
-      let [k, v] = _ref5;
-      return setCustom(k, v);
-    }); // local custom attrs are applied in either case with the highest precedence
+    if (localAttrs) Object.entries(localAttrs).forEach(([k, v]) => setCustom(k, v)); // local custom attrs are applied in either case with the highest precedence
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
     const aggregateHash = bucketHash + ':' + jsAttributesHash;
@@ -272,8 +253,7 @@ export class Aggregate extends AggregateBase {
       var jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
       this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs);
-      function setCustom(_ref6) {
-        let [key, val] = _ref6;
+      function setCustom([key, val]) {
         allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
       }
     });

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

@@ -12,10 +12,9 @@ import { now } from '../../../common/timing/now';
 import { SR_EVENT_EMITTER_TYPES } from '../../session_replay/constants';
 import { castError, castErrorEvent, castPromiseRejectionEvent } from '../shared/cast-error';
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   #replayRunning = false;
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     try {
       // this try-catch can be removed when IE11 is completely unsupported & gone
@@ -47,4 +46,5 @@ export class Instrument extends InstrumentBase {
     this.removeOnAbort?.abort();
     this.abortHandler = undefined; // weakly allow this abort op to run only once
   }
-}
+}
+export const JSErrors = Instrument;

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

@@ -1,4 +1,6 @@
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfigurationValue } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { handle } from '../../../common/event-emitter/handle';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -6,22 +8,21 @@ 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, LOG_LEVELS, MAX_PAYLOAD_SIZE } from '../constants';
+import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
 import { Log } from '../shared/log';
 import { isValidLogLevel } from '../shared/utils';
+import { applyFnToProps } from '../../../common/util/traverse';
+import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
+import { EventBuffer } from '../../utils/event-buffer';
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  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.bufferedLogs = new EventBuffer();
     this.#agentRuntime = getRuntime(this.agentIdentifier);
     this.#agentInfo = getInfo(this.agentIdentifier);
     this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'logging.harvestTimeSeconds');
@@ -32,16 +33,14 @@ export class Aggregate extends AggregateBase {
         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();
+      /** harvest immediately once started to purge pre-load logs collected */
+      this.scheduler.startTimer(this.harvestTimeSeconds, 0);
     });
   }
-  handleLog(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;
+  handleLog(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
     if (this.blocked) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
     if (typeof level === 'string') level = level.toUpperCase();
@@ -61,30 +60,26 @@ export class Aggregate extends AggregateBase {
       return;
     }
     if (typeof message !== 'string' || !message) return warn(32);
-    if (message.length > MAX_PAYLOAD_SIZE) {
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', message.length]);
-      return warn(31, message.slice(0, 25) + '...');
-    }
-    const log = new Log(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp), message, attributes, level);
+    const log = new Log(Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(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(31, 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({});
+
+    if (!this.bufferedLogs.canMerge(logBytes)) {
+      if (this.bufferedLogs.hasData) {
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.bufferedLogs.bytes + logBytes]);
+        this.scheduler.runHarvest({});
+        if (logBytes < MAX_PAYLOAD_SIZE) this.bufferedLogs.add(log);
+      } else {
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes]);
+        warn(31, log.message.slice(0, 25) + '...');
+      }
+      return;
     }
-    this.estimatedBytes += logBytes;
-    this.bufferedLogs.push(log);
+    this.bufferedLogs.add(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;
+  prepareHarvest(options = {}) {
+    if (this.blocked || !this.bufferedLogs.hasData) return;
     /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
-    return {
+    const payload = {
       qs: {
         browser_monitoring_key: this.#agentInfo.licenseKey
       },
@@ -110,11 +105,13 @@ export class Aggregate extends AggregateBase {
           }
         },
         /** logs section contains individual unique log entries */
-        logs: this.outgoingLogs
+        logs: applyFnToProps(this.bufferedLogs.buffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
       }]
     };
+    if (options.retry) this.bufferedLogs.hold();else this.bufferedLogs.clear();
+    return payload;
   }
   onHarvestFinished(result) {
-    if (!result.retry) this.outgoingLogs = [];
+    if (result.retry) this.bufferedLogs.unhold();else this.bufferedLogs.held.clear();
   }
 }

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

@@ -7,5 +7,4 @@ export const LOG_LEVELS = {
   TRACE: 'TRACE'
 };
 export const LOGGING_EVENT_EMITTER_CHANNEL = 'log';
-export const FEATURE_NAME = FEATURE_NAMES.logging;
-export const MAX_PAYLOAD_SIZE = 1000000;
+export const FEATURE_NAME = FEATURE_NAMES.logging;

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

@@ -2,14 +2,12 @@ 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;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = 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;
+    this.ee.on('wrap-logger-end', function handleLog([message]) {
       const {
         level,
         customAttributes
@@ -18,4 +16,5 @@ export class Instrument extends InstrumentBase {
     });
     this.importAggregator();
   }
-}
+}
+export const Logging = Instrument;

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

@@ -17,9 +17,7 @@ export class Log {
    * @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;
+  constructor(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
     /** @type {long} */
     this.timestamp = timestamp;
     this.message = message;

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

@@ -10,9 +10,7 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
    * @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;
+export function bufferLog(ee, message, customAttributes = {}, level = LOG_LEVELS.INFO) {
   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);
 }
@@ -24,5 +22,5 @@ export function bufferLog(ee, message) {
  */
 export function isValidLogLevel(level) {
   if (typeof level !== 'string') return false;
-  return Object.values(LOG_LEVELS).some(logLevel => logLevel === level);
+  return Object.values(LOG_LEVELS).some(logLevel => logLevel === level.toUpperCase().trim());
 }

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

@@ -1,21 +1,22 @@
-import { getRuntime, getConfiguration } from '../../../common/config/config';
+import { getConfiguration } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants';
+import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL, WATCHABLE_WEB_SOCKET_EVENTS } from '../constants';
 import { getFrameworks } from './framework-detection';
 import { isFileProtocol } from '../../../common/url/protocol';
-import { getRules, validateRules } from '../../../common/util/obfuscate';
 import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { deregisterDrain } from '../../../common/drain/drain';
+import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket';
+import { handleWebsocketEvents } from './websocket-detection';
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    this.waitForFlags(['err']).then(_ref => {
-      let [errFlag] = _ref;
+    this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
         // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
         const scheduler = new HarvestScheduler('jserrors', {
@@ -95,21 +96,32 @@ export class Aggregate extends AggregateBase {
     }
 
     // Capture SMs to assess customer engagement with the obfuscation config
-    const rules = getRules(this.agentIdentifier);
-    if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
-    if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
+    const ruleValidations = this.obfuscator.ruleValidationCache;
+    if (ruleValidations.length > 0) {
+      this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
+      if (ruleValidations.filter(ruleValidation => !ruleValidation.isValid).length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
+    }
 
     // Check if proxy for either chunks or beacon is being used
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
     if (isBrowserScope && window.MutationObserver) {
-      this.storeSupportabilityMetrics('Generic/VideoElement/Added', window.document.querySelectorAll('video').length);
+      if (window.self !== window.top) {
+        this.storeSupportabilityMetrics('Generic/Runtime/IFrame/Detected');
+      }
+      const preExistingVideos = window.document.querySelectorAll('video').length;
+      if (preExistingVideos) this.storeSupportabilityMetrics('Generic/VideoElement/Added', preExistingVideos);
+      const preExistingIframes = window.document.querySelectorAll('iframe').length;
+      if (preExistingIframes) this.storeSupportabilityMetrics('Generic/IFrame/Added', preExistingIframes);
       const mo = new MutationObserver(records => {
         records.forEach(record => {
           record.addedNodes.forEach(addedNode => {
             if (addedNode instanceof HTMLVideoElement) {
               this.storeSupportabilityMetrics('Generic/VideoElement/Added', 1);
             }
+            if (addedNode instanceof HTMLIFrameElement) {
+              this.storeSupportabilityMetrics('Generic/IFrame/Added', 1);
+            }
           });
         });
       });
@@ -118,6 +130,11 @@ export class Aggregate extends AggregateBase {
         subtree: true
       });
     }
+    WATCHABLE_WEB_SOCKET_EVENTS.forEach(tag => {
+      registerHandler('buffered-' + WEBSOCKET_TAG + tag, (...args) => {
+        handleWebsocketEvents(this.storeSupportabilityMetrics.bind(this), tag, ...args);
+      }, this.featureName, this.ee);
+    });
   }
   eachSessionChecks() {
     if (!isBrowserScope) return;
@@ -159,8 +176,8 @@ export class Aggregate extends AggregateBase {
       if (typeof performance !== 'undefined') {
         const markers = performance.getEntriesByType('mark');
         const measures = performance.getEntriesByType('measure');
-        this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length);
-        this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length);
+        if (markers.length) this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length);
+        if (measures.length) this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length);
       }
     } catch (e) {
       // do nothing

package/dist/esm/features/metrics/aggregate/websocket-detection.js

@@ -0,0 +1,29 @@
+import { dataSize } from '../../../common/util/data-size';
+import { toTitleCase } from '../../../common/util/text';
+import { ADD_EVENT_LISTENER_TAG } from '../../../common/wrap/wrap-websocket';
+
+/**
+ * A SM handler for web socket events, which converts them to a shape suitable for SMs and reports them.
+ * @param {Function} reporter a function that reports data as a supportability metric
+ * @param {string} tag the unique tag to assign to the sm
+ * @param {number} timestamp ms from page origin
+ * @param {number} timeSinceInit ms from class init
+ * @param {boolean} isLoaded whether the even was observed before the page load event
+ * @param {string} socketId a unique id assigned to the observed socket
+ * @param {*} data the data reported alongside the socket event
+ */
+export function handleWebsocketEvents(reporter, tag, timestamp, timeSinceInit, isLoaded, socketId, data) {
+  // socketId is unused in the SMs
+  const useDataType = tag === ADD_EVENT_LISTENER_TAG;
+  let metricTag = toTitleCase(useDataType ? data.eventType : tag);
+  if (metricTag === 'Close') {
+    if (data?.event.code === 1000 || data?.event.wasClean) metricTag += '-Clean';else metricTag += '-Dirty';
+  }
+  const bytes = metricTag === 'Message' && dataSize(data?.event?.data) || metricTag === 'Send' && dataSize(data);
+  reporter(buildSMTag(metricTag, 'Ms'), timestamp);
+  reporter(buildSMTag(metricTag, 'MsSinceClassInit'), timeSinceInit);
+  if (bytes) reporter(buildSMTag(metricTag, 'Bytes'), bytes);
+}
+function buildSMTag(tag, category) {
+  return 'WebSocket/' + tag + '/' + category;
+}

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

@@ -1,6 +1,8 @@
+import { ADD_EVENT_LISTENER_TAG } from '../../common/wrap/wrap-websocket';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.metrics;
 export const SUPPORTABILITY_METRIC = 'sm';
 export const CUSTOM_METRIC = 'cm';
 export const SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics';
-export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';
+export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';
+export const WATCHABLE_WEB_SOCKET_EVENTS = ['new', 'send', 'close', ADD_EVENT_LISTENER_TAG];

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

@@ -1,10 +1,18 @@
+import { handle } from '../../../common/event-emitter/handle';
+import { WEBSOCKET_TAG, wrapWebSocket } from '../../../common/wrap/wrap-websocket';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } from '../constants';
+import { FEATURE_NAME, WATCHABLE_WEB_SOCKET_EVENTS } from '../constants';
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    wrapWebSocket(this.ee);
+    WATCHABLE_WEB_SOCKET_EVENTS.forEach(suffix => {
+      this.ee.on(WEBSOCKET_TAG + suffix, (...args) => {
+        handle('buffered-' + WEBSOCKET_TAG + suffix, [...args], undefined, this.featureName, this.ee);
+      });
+    });
     this.importAggregator();
   }
-}
+}
+export const Metrics = Instrument;

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

@@ -9,8 +9,12 @@ import { GenericEvents } from '../../generic_events';
  * @deprecated This feature has been replaced by Generic Events. Use/Import `GenericEvents` instead. This wrapper will be removed in a future release
  */
 export class Instrument extends GenericEvents {
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, auto);
   }
-}
+}
+
+/**
+ * @deprecated This feature has been replaced by Generic Events. Use/Import `GenericEvents` instead. This wrapper will be removed in a future release
+ */
+export const PageAction = Instrument;

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

@@ -1,7 +1,8 @@
 import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
-import { getInfo, getRuntime, isConfigured } from '../../../common/config/config';
+import { getInfo, isValid } from '../../../common/config/info';
+import { getRuntime } from '../../../common/config/runtime';
 import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
@@ -11,30 +12,26 @@ import { AggregateBase } from '../../utils/aggregate-base';
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint';
 import { firstPaint } from '../../../common/vitals/first-paint';
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
-import { drain } from '../../../common/drain/drain';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { handle } from '../../../common/event-emitter/handle';
-import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { now } from '../../../common/timing/now';
 import { TimeKeeper } from '../../../common/timing/time-keeper';
+import { applyFnToProps } from '../../../common/util/traverse';
 export class Aggregate extends AggregateBase {
-  static featureName = (() => CONSTANTS.FEATURE_NAME)();
+  static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME);
     this.timeToFirstByte = 0;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
     this.timeKeeper = new TimeKeeper(this.agentIdentifier);
-    if (!isConfigured(agentIdentifier)) {
+    if (!isValid(agentIdentifier)) {
       this.ee.abort();
       return warn(43);
     }
     if (isBrowserScope) {
-      timeToFirstByte.subscribe(_ref => {
-        let {
-          value,
-          attrs
-        } = _ref;
+      timeToFirstByte.subscribe(({
+        value,
+        attrs
+      }) => {
         const navEntry = attrs.navigationEntry;
         this.timeToFirstByte = Math.max(value, this.timeToFirstByte);
         this.firstByteToWindowLoad = Math.max(Math.round(navEntry.loadEventEnd - this.timeToFirstByte), this.firstByteToWindowLoad); // our "frontend" duration
@@ -76,8 +73,7 @@ export class Aggregate extends AggregateBase {
       ac: info.account,
       pr: info.product,
       af: getActivatedFeaturesFlags(this.agentIdentifier).join(','),
-      ...Object.entries(this.aggregator.get('measures') || {}).reduce((aggregator, _ref2) => {
-        let [metricName, measure] = _ref2;
+      ...Object.entries(this.aggregator.get('measures') || {}).reduce((aggregator, [metricName, measure]) => {
         aggregator[metricName] = measure.params?.value;
         return aggregator;
       }, {}),
@@ -89,9 +85,9 @@ export class Aggregate extends AggregateBase {
 
     let body;
     if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
-      body = {
+      body = applyFnToProps({
         ja: info.jsAttributes
-      };
+      }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
     }
     if (globalScope.performance) {
       if (typeof PerformanceNavigationTiming !== 'undefined') {
@@ -114,7 +110,7 @@ export class Aggregate extends AggregateBase {
     queryParameters.fp = firstPaint.current.value;
     queryParameters.fcp = firstContentfulPaint.current.value;
     if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = this.timeKeeper.convertRelativeTimestamp(now());
+      queryParameters.timestamp = Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(now())));
     }
     const rumStartTime = now();
     harvester.send({
@@ -127,12 +123,11 @@ export class Aggregate extends AggregateBase {
         needResponse: true,
         sendEmptyBody: true
       },
-      cbFinished: _ref3 => {
-        let {
-          status,
-          responseText,
-          xhr
-        } = _ref3;
+      cbFinished: ({
+        status,
+        responseText,
+        xhr
+      }) => {
         const rumEndTime = now();
         if (status >= 400 || status === 0) {
           // Adding retry logic for the rum call will be a separate change
@@ -143,22 +138,7 @@ export class Aggregate extends AggregateBase {
           this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
           if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready');
           agentRuntime.timeKeeper = this.timeKeeper;
-
-          // Check if the time diff is such that we need to capture a supportability metric
-          if (this.timeKeeper.localTimeDiff >= 12 * 60 * 60 * 1000) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed12Hrs'], undefined, FEATURE_NAMES.metrics, this.ee);
-          } else if (this.timeKeeper.localTimeDiff >= 6 * 60 * 60 * 1000) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed6Hrs'], undefined, FEATURE_NAMES.metrics, this.ee);
-          } else if (this.timeKeeper.localTimeDiff >= 60 * 60 * 1000) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed1Hrs'], undefined, FEATURE_NAMES.metrics, this.ee);
-          }
         } catch (error) {
-          if (error?.message?.indexOf('invalid format') > 0) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/InvalidFormat'], undefined, FEATURE_NAMES.metrics, this.ee);
-          } else {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, FEATURE_NAMES.metrics, this.ee);
-          }
-          drain(this.agentIdentifier, FEATURE_NAMES.metrics, true);
           this.ee.abort();
           warn(17, error);
           return;