@newrelic/browser-agent 1.263.0 → 1.265.0

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

@@ -3,13 +3,11 @@ 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;
+  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;
   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;
+  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

@@ -3,13 +3,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } 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;
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    this.importAggregator();
+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, 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,12 +12,9 @@ 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;
   constructor(agentIdentifier, aggregator) {
@@ -25,16 +23,15 @@ export class Aggregate extends AggregateBase {
     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;

package/dist/esm/features/page_view_event/aggregate/initialized-features.js

@@ -19,7 +19,7 @@ export function getActivatedFeaturesFlags(agentId) {
         case FEATURE_NAMES.jserrors:
           flagArr.push('err');
           break;
-        case FEATURE_NAMES.pageAction:
+        case FEATURE_NAMES.genericEvents:
           flagArr.push('ins');
           break;
         case FEATURE_NAMES.sessionTrace:

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

@@ -2,9 +2,9 @@ import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = CONSTANTS.FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME, auto);
     this.importAggregator();
   }
-}
+}
+export const PageViewEvent = Instrument;

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

@@ -4,11 +4,11 @@
  */
 
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
-import { mapOwn } from '../../../common/util/map-own';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { handle } from '../../../common/event-emitter/handle';
-import { getInfo, getConfigurationValue } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfigurationValue } from '../../../common/config/init';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
@@ -22,22 +22,19 @@ import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
 import { longTask } from '../../../common/vitals/long-task';
 import { subscribeToVisibilityChange } from '../../../common/window/page-visibility';
 import { VITAL_NAMES } from '../../../common/vitals/constants';
+import { EventBuffer } from '../../utils/event-buffer';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  #handleVitalMetric = _ref => {
-    let {
-      name,
-      value,
-      attrs
-    } = _ref;
+  #handleVitalMetric = ({
+    name,
+    value,
+    attrs
+  }) => {
     this.addTiming(name, value, attrs);
   };
   constructor(agentIdentifier, aggregator) {
-    var _this;
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    _this = this;
-    this.timings = [];
-    this.timingsSent = [];
+    this.timings = new EventBuffer();
     this.curSessEndRecorded = false;
     if (getConfigurationValue(this.agentIdentifier, 'page_view_timing.long_task') === true) longTask.subscribe(this.#handleVitalMetric);
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee);
@@ -51,10 +48,9 @@ export class Aggregate extends AggregateBase {
       firstInputDelay.subscribe(this.#handleVitalMetric);
       largestContentfulPaint.subscribe(this.#handleVitalMetric);
       interactionToNextPaint.subscribe(this.#handleVitalMetric);
-      timeToFirstByte.subscribe(_ref2 => {
-        let {
-          attrs
-        } = _ref2;
+      timeToFirstByte.subscribe(({
+        attrs
+      }) => {
         this.addTiming('load', Math.round(attrs.navigationEntry.loadEventEnd));
       });
       subscribeToVisibilityChange(() => {
@@ -71,12 +67,8 @@ export class Aggregate extends AggregateBase {
       }, true); // CLS node should only reports on vis change rather than on every change
 
       const scheduler = new HarvestScheduler('events', {
-        onFinished: function () {
-          return _this.onHarvestFinished(...arguments);
-        },
-        getPayload: function () {
-          return _this.prepareHarvest(...arguments);
-        }
+        onFinished: (...args) => this.onHarvestFinished(...args),
+        getPayload: (...args) => this.prepareHarvest(...args)
       }, this);
       scheduler.startTimer(harvestTimeSeconds);
       this.drain();
@@ -124,7 +116,7 @@ export class Aggregate extends AggregateBase {
     if (name !== VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT && cumulativeLayoutShift.current.value >= 0) {
       attrs.cls = cumulativeLayoutShift.current.value;
     }
-    this.timings.push({
+    this.timings.add({
       name,
       value,
       attrs
@@ -132,16 +124,13 @@ export class Aggregate extends AggregateBase {
     handle('pvtAdded', [name, value, attrs], undefined, FEATURE_NAMES.sessionTrace, this.ee);
   }
   onHarvestFinished(result) {
-    if (result.retry && this.timingsSent.length > 0) {
-      this.timings.unshift(...this.timingsSent);
-      this.timingsSent = [];
-    }
+    if (result.retry && this.timings.held.hasData) this.timings.unhold();else this.timings.held.clear();
   }
   appendGlobalCustomAttributes(timing) {
     var timingAttributes = timing.attrs || {};
     var customAttributes = getInfo(this.agentIdentifier).jsAttributes || {};
     var reservedAttributes = ['size', 'eid', 'cls', 'type', 'fid', 'elTag', 'elUrl', 'net-type', 'net-etype', 'net-rtt', 'net-dlink'];
-    mapOwn(customAttributes, function (key, val) {
+    Object.entries(customAttributes || {}).forEach(([key, val]) => {
       if (reservedAttributes.indexOf(key) < 0) {
         timingAttributes[key] = val;
       }
@@ -150,14 +139,9 @@ export class Aggregate extends AggregateBase {
 
   // serialize and return current timing data, clear and save current data for retry
   prepareHarvest(options) {
-    if (this.timings.length === 0) return;
-    var payload = this.getPayload(this.timings);
-    if (options.retry) {
-      for (var i = 0; i < this.timings.length; i++) {
-        this.timingsSent.push(this.timings[i]);
-      }
-    }
-    this.timings = [];
+    if (!this.timings.hasData) return;
+    var payload = this.getPayload(this.timings.buffer);
+    if (options.retry) this.timings.hold();else this.timings.clear();
     return {
       body: {
         e: payload

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

@@ -11,8 +11,7 @@ import { isBrowserScope } from '../../../common/constants/runtime';
 import { now } from '../../../common/timing/now';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  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);
     if (!isBrowserScope) return; // CWV is irrelevant outside web context
 
@@ -23,4 +22,5 @@ export class Instrument extends InstrumentBase {
     windowAddEventListener('pagehide', () => handle('winPagehide', [now()], undefined, FEATURE_NAME, this.ee));
     this.importAggregator();
   }
-}
+}
+export const PageViewTiming = Instrument;