@newrelic/browser-agent 1.271.0 → 1.273.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.273.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.272.0...v1.273.0) (2024-11-11)
+
+
+### Features
+
+* Refactor feature storages ([#1241](https://github.com/newrelic/newrelic-browser-agent/issues/1241)) ([f77380b](https://github.com/newrelic/newrelic-browser-agent/commit/f77380b01e9b57db0b5c782d6d512431229bcd79))
+* Remove wrap-events usage from soft nav ([#1244](https://github.com/newrelic/newrelic-browser-agent/issues/1244)) ([911d8d1](https://github.com/newrelic/newrelic-browser-agent/commit/911d8d1d78b49fa4252257596e013806885ace9b))
+
+## [1.272.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.271.0...v1.272.0) (2024-11-07)
+
+
+### Features
+
+* Marks and measures ([#1189](https://github.com/newrelic/newrelic-browser-agent/issues/1189)) ([1a58409](https://github.com/newrelic/newrelic-browser-agent/commit/1a58409cda8b7b264e58fe284041540941dccd1c))
+
 ## [1.271.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.270.3...v1.271.0) (2024-11-01)
 
 

package/dist/cjs/common/aggregate/aggregator.js

@@ -4,15 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Aggregator = void 0;
-var _sharedContext = require("../context/shared-context");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
-class Aggregator extends _sharedContext.SharedContext {
-  constructor(parent) {
-    super(parent);
+class Aggregator {
+  constructor() {
     this.aggregatedData = {};
   }
 
@@ -21,12 +18,14 @@ class Aggregator extends _sharedContext.SharedContext {
   // metrics are the numeric values to be aggregated
 
   store(type, name, params, newMetrics, customParams) {
-    var bucket = this.getBucket(type, name, params, customParams);
+    var bucket = this.#getBucket(type, name, params, customParams);
     bucket.metrics = aggregateMetrics(newMetrics, bucket.metrics);
     return bucket;
   }
-  merge(type, name, metrics, params, customParams) {
-    var bucket = this.getBucket(type, name, params, customParams);
+  merge(type, name, metrics, params, customParams, overwriteParams = false) {
+    var bucket = this.#getBucket(type, name, params, customParams);
+    if (overwriteParams) bucket.params = params; // replace current params with incoming params obj
+
     if (!bucket.metrics) {
       bucket.metrics = metrics;
       return;
@@ -51,11 +50,25 @@ class Aggregator extends _sharedContext.SharedContext {
     });
   }
   storeMetric(type, name, params, value) {
-    var bucket = this.getBucket(type, name, params);
+    var bucket = this.#getBucket(type, name, params);
     bucket.stats = updateMetric(value, bucket.stats);
     return bucket;
   }
-  getBucket(type, name, params, customParams) {
+
+  // Get all listed types buckets and it deletes the retrieved content from the aggregatedData
+  take(types, deleteWhenRetrieved = true) {
+    var results = {};
+    var type = '';
+    var hasData = false;
+    for (var i = 0; i < types.length; i++) {
+      type = types[i];
+      results[type] = Object.values(this.aggregatedData[type] || {});
+      if (results[type].length) hasData = true;
+      if (deleteWhenRetrieved) delete this.aggregatedData[type];
+    }
+    return hasData ? results : null;
+  }
+  #getBucket(type, name, params, customParams) {
     if (!this.aggregatedData[type]) this.aggregatedData[type] = {};
     var bucket = this.aggregatedData[type][name];
     if (!bucket) {
@@ -68,26 +81,6 @@ class Aggregator extends _sharedContext.SharedContext {
     }
     return bucket;
   }
-  get(type, name) {
-    // if name is passed, get a single bucket
-    if (name) return this.aggregatedData[type] && this.aggregatedData[type][name];
-    // else, get all buckets of that type
-    return this.aggregatedData[type];
-  }
-
-  // Like get, but for many types and it deletes the retrieved content from the aggregatedData
-  take(types) {
-    var results = {};
-    var type = '';
-    var hasData = false;
-    for (var i = 0; i < types.length; i++) {
-      type = types[i];
-      results[type] = Object.values(this.aggregatedData[type] || {});
-      if (results[type].length) hasData = true;
-      delete this.aggregatedData[type];
-    }
-    return hasData ? results : null;
-  }
 }
 exports.Aggregator = Aggregator;
 function aggregateMetrics(newMetrics, oldMetrics) {

package/dist/cjs/common/aggregate/event-aggregator.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventAggregator = void 0;
+var _aggregator = require("./aggregator");
+/**
+ * An extension of the Aggregator class that provides an interface similar to that of EventBuffer class.
+ * This typecasting allow features that uses Aggregator as their event handler to share the same AggregateBase.events utilization by those features.
+ */
+class EventAggregator {
+  #aggregator = new _aggregator.Aggregator();
+  #savedNamesToBuckets = {};
+  isEmpty({
+    aggregatorTypes
+  }) {
+    if (!aggregatorTypes) return Object.keys(this.#aggregator.aggregatedData).length === 0;
+    return aggregatorTypes.every(type => !this.#aggregator.aggregatedData[type]); // no bucket exist for any of the types we're looking for
+  }
+  add(type, name, params, newMetrics, customParams) {
+    // Do we need to track byte size here like EventBuffer?
+    this.#aggregator.store(type, name, params, newMetrics, customParams);
+    return true;
+  }
+  addMetric(type, name, params, value) {
+    this.#aggregator.storeMetric(type, name, params, value);
+    return true;
+  }
+  save({
+    aggregatorTypes
+  }) {
+    const key = aggregatorTypes.toString(); // the stringified types serve as the key to each save call, e.g. ['err', 'ierr', 'xhr'] => 'err,ierr,xhr'
+    const backupAggregatedDataSubset = {};
+    aggregatorTypes.forEach(type => backupAggregatedDataSubset[type] = this.#aggregator.aggregatedData[type]); // make a subset of the aggregatedData for each of the types we want to save
+    this.#savedNamesToBuckets[key] = backupAggregatedDataSubset;
+    /*
+    { 'err,ierr,xhr': {
+        'err': {
+            <aggregateHash>: { metrics: { count: 1, time, ... }, params: {}, custom: {} },
+            <otherHashName>: { metrics: { count: 1, ... }, ... }
+        },
+        'ierr': { ... },
+        'xhr': { ... }
+      }
+    }
+    */
+  }
+  get(opts) {
+    const aggregatorTypes = Array.isArray(opts) ? opts : opts.aggregatorTypes;
+    return this.#aggregator.take(aggregatorTypes, false);
+  }
+  clear({
+    aggregatorTypes
+  } = {}) {
+    if (!aggregatorTypes) {
+      this.#aggregator.aggregatedData = {};
+      return;
+    }
+    aggregatorTypes.forEach(type => delete this.#aggregator.aggregatedData[type]);
+  }
+  reloadSave({
+    aggregatorTypes
+  }) {
+    const key = aggregatorTypes.toString();
+    const backupAggregatedDataSubset = this.#savedNamesToBuckets[key];
+    // Grabs the previously stored subset and merge it back into aggregatedData.
+    aggregatorTypes.forEach(type => {
+      Object.keys(backupAggregatedDataSubset[type] || {}).forEach(name => {
+        const bucket = backupAggregatedDataSubset[type][name];
+        // The older aka saved params take effect over the newer one. This is especially important when merging back for a failed harvest retry if, for example,
+        // the first-ever occurrence of an error is in the retry: it contains the params.stack_trace whereas the newer or current bucket.params would not.
+        this.#aggregator.merge(type, name, bucket.metrics, bucket.params, bucket.custom, true);
+      });
+    });
+  }
+  clearSave({
+    aggregatorTypes
+  }) {
+    const key = aggregatorTypes.toString();
+    delete this.#savedNamesToBuckets[key];
+  }
+}
+exports.EventAggregator = EventAggregator;

package/dist/cjs/common/config/init.js

@@ -80,9 +80,6 @@ const model = () => {
     page_action: {
       enabled: true
     },
-    user_actions: {
-      enabled: true
-    },
     page_view_event: {
       enabled: true,
       autoStart: true
@@ -92,6 +89,10 @@ const model = () => {
       harvestTimeSeconds: 30,
       autoStart: true
     },
+    performance: {
+      capture_marks: false,
+      capture_measures: false // false by default through experimental phase, but flipped to true once GA'd
+    },
     privacy: {
       cookies_enabled: true
     },
@@ -175,7 +176,10 @@ const model = () => {
       harvestTimeSeconds: 10,
       autoStart: true
     },
-    ssl: undefined
+    ssl: undefined,
+    user_actions: {
+      enabled: true
+    }
   };
 };
 const _cache = {};

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.271.0";
+const VERSION = exports.VERSION = "1.273.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.271.0";
+const VERSION = exports.VERSION = "1.273.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -102,7 +102,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     let submitMethod;
     let payload;
     if (this.opts.getPayload) {
-      // Ajax & PVT & SR features provide a callback function to get data for harvesting
+      // Ajax, PVT, Softnav, Logging, SR & ST features provide a single callback function to get data for harvesting
       submitMethod = submitData.getSubmitMethod({
         isFinalHarvest: opts?.unload
       });

package/dist/cjs/common/harvest/harvest.js

@@ -128,11 +128,7 @@ class Harvest extends _sharedContext.SharedContext {
     const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
     const gzip = !!qs?.attributes?.includes('gzip');
     if (!gzip) {
-      if (endpoint === 'events') {
-        body = body.e;
-      } else {
-        body = (0, _stringify.stringify)(body);
-      }
+      if (endpoint !== 'events') body = (0, _stringify.stringify)(body); // all features going to /events/ endpoint should already be serialized & stringified
       /** Warn --once per endpoint-- if the agent tries to send large payloads */
       if (body.length > 750000 && (warnings[endpoint] = (warnings?.[endpoint] || 0) + 1) === 1) (0, _console.warn)(28, endpoint);
     }

package/dist/cjs/common/harvest/types.js

@@ -18,7 +18,6 @@ exports.unused = void 0;
  * @typedef {object} HarvestPayload
  * @property {object} qs Map of values that should be sent as part of the request query string.
  * @property {object} body Map of values that should be sent as the body of the request.
- * @property {string} body.e Special case of body used for browser interactions.
  */
 
 /**

package/dist/cjs/features/ajax/aggregate/index.js

@@ -14,10 +14,7 @@ var _features = require("../../../loaders/features/features");
 var _constants2 = require("../../metrics/constants");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _gql = require("./gql");
-var _nreum = require("../../../common/window/nreum");
-var _chunk = _interopRequireDefault(require("./chunk"));
-var _eventBuffer = require("../../utils/event-buffer");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _belSerializer = require("../../../common/serialize/bel-serializer");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -29,31 +26,30 @@ class Aggregate extends _aggregateBase.AggregateBase {
     super(agentRef, _constants.FEATURE_NAME);
     const harvestTimeSeconds = agentRef.init.ajax.harvestTimeSeconds || 10;
     (0, _denyList.setDenyList)(agentRef.runtime.denyList);
-    this.ajaxEvents = new _eventBuffer.EventBuffer();
-    this.spaAjaxEvents = {};
+    this.underSpaEvents = {};
     const classThis = this;
 
     // --- v Used by old spa feature
     this.ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!this.spaAjaxEvents[interaction.id]?.hasData) return;
+      if (!this.underSpaEvents[interaction.id]) return;
       if (!wasSaved) {
         // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
-        this.ajaxEvents.merge(this.spaAjaxEvents[interaction.id]);
+        this.underSpaEvents[interaction.id].forEach(item => this.events.add(item));
       }
-      delete this.spaAjaxEvents[interaction.id];
+      delete this.underSpaEvents[interaction.id];
     });
     // --- ^
     // --- v Used by new soft nav
-    (0, _registerHandler.registerHandler)('returnAjax', event => this.ajaxEvents.add(event), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('returnAjax', event => this.events.add(event), this.featureName, this.ee);
     // --- ^
     (0, _registerHandler.registerHandler)('xhr', function () {
       // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
       classThis.storeXhr(...arguments, this); // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
     }, this.featureName, this.ee);
     this.waitForFlags([]).then(() => {
-      const scheduler = new _harvestScheduler.HarvestScheduler('events', {
-        onFinished: this.onEventsHarvestFinished.bind(this),
-        getPayload: this.prepareHarvest.bind(this)
+      const scheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
+        getPayload: options => this.makeHarvestPayload(options.retry)
       }, this);
       scheduler.startTimer(harvestTimeSeconds);
       this.drain();
@@ -71,10 +67,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     const shouldCollect = (0, _denyList.shouldCollectEvent)(params);
     const shouldOmitAjaxMetrics = this.agentRef.init.feature_flags?.includes('ajax_metrics_deny_list');
+    const jserrorsInUse = Boolean(this.agentRef.features?.[_features.FEATURE_NAMES.jserrors]);
 
-    // store for timeslice metric (harvested by jserrors feature)
-    if (shouldCollect || !shouldOmitAjaxMetrics) {
-      this.agentRef.sharedAggregator.store('xhr', hash, params, metrics);
+    // Report ajax timeslice metric (to be harvested by jserrors feature, but only if it's running).
+    if (jserrorsInUse && (shouldCollect || !shouldOmitAjaxMetrics)) {
+      this.agentRef.sharedAggregator.add('xhr', hash, params, metrics);
     }
     if (!shouldCollect) {
       if (params.hostname === this.agentRef.info.errorBeacon || this.agentRef.init.proxy?.beacon && params.hostname === this.agentRef.init.proxy.beacon) {
@@ -113,63 +110,56 @@ class Aggregate extends _aggregateBase.AggregateBase {
       query: ctx.parsedOrigin?.search
     });
     if (event.gql) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', (0, _stringify.stringify)(event.gql).length], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-    const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features?.[_features.FEATURE_NAMES.softNav]);
+    const softNavInUse = Boolean(this.agentRef.features?.[_features.FEATURE_NAMES.softNav]);
     if (softNavInUse) {
       // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
       (0, _handle.handle)('ajax', [event], undefined, _features.FEATURE_NAMES.softNav, this.ee);
     } else if (ctx.spaNode) {
       // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
       const interactionId = ctx.spaNode.interaction.id;
-      this.spaAjaxEvents[interactionId] ??= new _eventBuffer.EventBuffer();
-      this.spaAjaxEvents[interactionId].add(event);
+      this.underSpaEvents[interactionId] ??= [];
+      this.underSpaEvents[interactionId].push(event);
     } else {
-      this.ajaxEvents.add(event);
+      this.events.add(event);
     }
   }
-  prepareHarvest(options) {
-    options = options || {};
-    if (this.ajaxEvents.buffer.length === 0) return null;
-    const payload = this.#getPayload(this.ajaxEvents.buffer);
-    const payloadObjs = [];
-    for (let i = 0; i < payload.length; i++) payloadObjs.push({
-      body: {
-        e: payload[i]
-      }
-    });
-    if (options.retry) this.ajaxEvents.hold();else this.ajaxEvents.clear();
-    return payloadObjs;
-  }
-  onEventsHarvestFinished(result) {
-    if (result.retry && this.ajaxEvents.held.hasData) this.ajaxEvents.unhold();else this.ajaxEvents.held.clear();
-  }
-  #getPayload(events, numberOfChunks) {
-    numberOfChunks = numberOfChunks || 1;
-    const payload = [];
-    const chunkSize = events.length / numberOfChunks;
-    const eventChunks = splitChunks.call(this, events, chunkSize);
-    let tooBig = false;
-    for (let i = 0; i < eventChunks.length; i++) {
-      const currentChunk = eventChunks[i];
-      if (currentChunk.tooBig) {
-        if (currentChunk.events.length > 1) {
-          tooBig = true;
-          break; // if the payload is too big BUT is made of more than 1 event, we can split it down again
-        }
-        // Otherwise, if it consists of one sole event, we do not send it (discarded) since we cannot break it apart any further.
-      } else {
-        payload.push(currentChunk.payload);
-      }
-    }
-    // Check if the current payload string is too big, if so then run getPayload again with more buckets.
-    return tooBig ? this.#getPayload(events, ++numberOfChunks) : payload;
-    function splitChunks(arr, chunkSize) {
-      chunkSize = chunkSize || arr.length;
-      const chunks = [];
-      for (let i = 0, len = arr.length; i < len; i += chunkSize) {
-        chunks.push(new _chunk.default(arr.slice(i, i + chunkSize), this));
+  serializer(eventBuffer) {
+    const addString = (0, _belSerializer.getAddStringContext)(this.agentIdentifier);
+    let payload = 'bel.7;';
+    for (let i = 0; i < eventBuffer.length; i++) {
+      const event = eventBuffer[i];
+      const fields = [(0, _belSerializer.numeric)(event.startTime), (0, _belSerializer.numeric)(event.endTime - event.startTime), (0, _belSerializer.numeric)(0),
+      // callbackEnd
+      (0, _belSerializer.numeric)(0),
+      // no callbackDuration for non-SPA events
+      addString(event.method), (0, _belSerializer.numeric)(event.status), addString(event.domain), addString(event.path), (0, _belSerializer.numeric)(event.requestSize), (0, _belSerializer.numeric)(event.responseSize), event.type === 'fetch' ? 1 : '', addString(0),
+      // nodeId
+      (0, _belSerializer.nullable)(event.spanId, addString, true) +
+      // guid
+      (0, _belSerializer.nullable)(event.traceId, addString, true) +
+      // traceId
+      (0, _belSerializer.nullable)(event.spanTimestamp, _belSerializer.numeric, false) // timestamp
+      ];
+      let insert = '2,';
+
+      // Since configuration objects (like info) are created new each time they are set, we have to grab the current pointer to the attr object here.
+      const jsAttributes = this.agentRef.info.jsAttributes;
+
+      // add custom attributes
+      // gql decorators are added as custom attributes to alleviate need for new BEL schema
+      const attrParts = (0, _belSerializer.addCustomAttributes)({
+        ...(jsAttributes || {}),
+        ...(event.gql || {})
+      }, addString);
+      fields.unshift((0, _belSerializer.numeric)(attrParts.length));
+      insert += fields.join(',');
+      if (attrParts && attrParts.length > 0) {
+        insert += ';' + attrParts.join(';');
       }
-      return chunks;
+      if (i + 1 < eventBuffer.length) insert += ';';
+      payload += insert;
     }
+    return payload;
   }
 }
 exports.Aggregate = Aggregate;

package/dist/cjs/features/generic_events/aggregate/index.js

@@ -14,9 +14,9 @@ var _console = require("../../../common/util/console");
 var _now = require("../../../common/timing/now");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _constants2 = require("../../metrics/constants");
-var _eventBuffer = require("../../utils/event-buffer");
 var _traverse = require("../../../common/util/traverse");
 var _agentConstants = require("../../../common/constants/agent-constants");
+var _features = require("../../../loaders/features/features");
 var _userActionsAggregator = require("./user-actions/user-actions-aggregator");
 var _iframe = require("../../../common/dom/iframe");
 /*
@@ -31,14 +31,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.eventsPerHarvest = 1000;
     this.harvestTimeSeconds = agentRef.init.generic_events.harvestTimeSeconds;
     this.referrerUrl = _runtime.isBrowserScope && document.referrer ? (0, _cleanUrl.cleanURL)(document.referrer) : undefined;
-    this.events = new _eventBuffer.EventBuffer();
     this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
         this.blocked = true;
         this.deregisterDrain();
         return;
       }
-      const preHarvestMethods = [];
       if (agentRef.init.page_action.enabled) {
         (0, _registerHandler.registerHandler)('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
@@ -55,9 +53,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
           });
         }, this.featureName, this.ee);
       }
+      let addUserAction;
       if (_runtime.isBrowserScope && agentRef.init.user_actions.enabled) {
         this.userActionAggregator = new _userActionsAggregator.UserActionsAggregator();
-        this.addUserAction = aggregatedUserAction => {
+        addUserAction = aggregatedUserAction => {
           try {
             /** The aggregator process only returns an event when it is "done" aggregating -
              * so we still need to validate that an event was given to this method before we try to add */
@@ -99,21 +98,53 @@ class Aggregate extends _aggregateBase.AggregateBase {
         };
         (0, _registerHandler.registerHandler)('ua', evt => {
           /** the processor will return the previously aggregated event if it has been completed by processing the current event */
-          this.addUserAction(this.userActionAggregator.process(evt));
+          addUserAction(this.userActionAggregator.process(evt));
         }, this.featureName, this.ee);
-        preHarvestMethods.push((options = {}) => {
-          /** send whatever UserActions have been aggregated up to this point
-           * if we are in a final harvest. By accessing the aggregationEvent, the aggregation is then force-cleared */
-          if (options.isFinalHarvest) this.addUserAction(this.userActionAggregator.aggregationEvent);
-        });
       }
-      this.harvestScheduler = new _harvestScheduler.HarvestScheduler('ins', {
-        onFinished: (...args) => this.onHarvestFinished(...args)
+
+      /**
+       * is it worth complicating the agent and skipping the POs for single repeating queries? maybe,
+       * but right now it was less desirable simply because it is a nice benefit of populating the event buffer
+       * immediately as events happen for payload evaluation purposes and that becomes a little more chaotic
+       * with an arbitrary query method. note: eventTypes: [...types] does not support the 'buffered' flag so we have
+       * to create up to two PO's here.
+       */
+      const performanceTypesToCapture = [...(agentRef.init.performance.capture_marks ? ['mark'] : []), ...(agentRef.init.performance.capture_measures ? ['measure'] : [])];
+      if (performanceTypesToCapture.length) {
+        try {
+          performanceTypesToCapture.forEach(type => {
+            if (PerformanceObserver.supportedEntryTypes.includes(type)) {
+              const observer = new PerformanceObserver(list => {
+                list.getEntries().forEach(entry => {
+                  try {
+                    this.addEvent({
+                      eventType: 'BrowserPerformance',
+                      timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entry.startTime)),
+                      entryName: entry.name,
+                      entryDuration: entry.duration,
+                      entryType: type,
+                      ...(entry.detail && {
+                        entryDetail: entry.detail
+                      })
+                    });
+                  } catch (err) {}
+                });
+              });
+              observer.observe({
+                buffered: true,
+                type
+              });
+            }
+          });
+        } catch (err) {
+          // Something failed in our set up, likely the browser does not support PO's... do nothing
+        }
+      }
+      this.harvestScheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
+        onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
       }, this);
-      this.harvestScheduler.harvest.on('ins', (...args) => {
-        preHarvestMethods.forEach(fn => fn(...args));
-        return this.onHarvestStarted(...args);
-      });
+      this.harvestScheduler.harvest.on(_features.FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry));
       this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
       this.drain();
     });
@@ -160,30 +191,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.events.add(eventAttributes);
     this.checkEventLimits();
   }
-  onHarvestStarted(options) {
-    const {
-      userAttributes,
-      atts
-    } = this.agentRef.info;
-    if (!this.events.hasData) return;
-    var payload = {
-      qs: {
-        ua: userAttributes,
-        at: atts
-      },
-      body: (0, _traverse.applyFnToProps)({
-        ins: this.events.buffer
-      }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
-    };
-    if (options.retry) this.events.hold();else this.events.clear();
-    return payload;
+  serializer(eventBuffer) {
+    return (0, _traverse.applyFnToProps)({
+      ins: eventBuffer
+    }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
   }
-  onHarvestFinished(result) {
-    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold();else this.events.held.clear();
+  queryStringsBuilder() {
+    return {
+      ua: this.agentRef.info.userAttributes,
+      at: this.agentRef.info.atts
+    };
   }
   checkEventLimits() {
     // check if we've reached any harvest limits...
-    if (this.events.bytes > _agentConstants.IDEAL_PAYLOAD_SIZE) {
+    if (this.events.byteSize() > _agentConstants.IDEAL_PAYLOAD_SIZE) {
       this.ee.emit(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen']);
       this.harvestScheduler.runHarvest();
     }

package/dist/cjs/features/generic_events/instrument/index.js

@@ -17,7 +17,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, _constants.FEATURE_NAME, auto);
-    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.user_actions.enabled
+    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.user_actions.enabled
     // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
     ];
     if (_runtime.isBrowserScope && agentRef.init.user_actions.enabled) {