@newrelic/browser-agent 1.271.0 → 1.273.0

package/dist/cjs/features/utils/event-buffer.js

@@ -6,128 +6,77 @@ Object.defineProperty(exports, "__esModule", {
 exports.EventBuffer = void 0;
 var _stringify = require("../../common/util/stringify");
 var _agentConstants = require("../../common/constants/agent-constants");
-/**
- * A container that keeps an event buffer and size with helper methods
- * @typedef {Object} EventBuffer
- * @property {number} size
- * @property {*[]} buffer
- */
-
-/**
- * A container that holds, evaluates, and merges event objects for harvesting
- */
 class EventBuffer {
-  /** @type {Object[]} */
   #buffer = [];
-  /** @type {number} */
-  #bytes = 0;
-  /** @type {EventBuffer} */
-  #held;
+  #rawBytes = 0;
+  #bufferBackup;
+  #rawBytesBackup;
 
   /**
-   *
-   * @param {number=} maxPayloadSize
+   * @param {number} maxPayloadSize
    */
   constructor(maxPayloadSize = _agentConstants.MAX_PAYLOAD_SIZE) {
     this.maxPayloadSize = maxPayloadSize;
   }
-
-  /**
-   * buffer is read only, use the helper methods to add or clear buffer data
-   */
-  get buffer() {
+  isEmpty() {
+    return this.#buffer.length === 0;
+  }
+  get() {
     return this.#buffer;
   }
-
-  /**
-   * bytes is read only, use the helper methods to add or clear buffer data
-   */
-  get bytes() {
-    return this.#bytes;
+  byteSize() {
+    return this.#rawBytes;
   }
-
-  /**
-   * held is another event buffer
-   */
-  get held() {
-    if (!this.#held) this.#held = new EventBuffer(this.maxPayloadSize);
-    return this.#held;
-  }
-
-  /**
-   * Returns a boolean indicating whether the current size and buffer contain valid data
-   * @returns {boolean}
-   */
-  get hasData() {
-    return this.buffer.length > 0 && this.bytes > 0;
+  wouldExceedMaxSize(incomingSize) {
+    return this.#rawBytes + incomingSize > this.maxPayloadSize;
   }
 
   /**
-   * Adds an event object to the buffer while tallying size. Only adds the event if it is valid
-   * and would not make the event buffer exceed the maxPayloadSize.
-   * @param {Object} event the event object to add to the buffer
-   * @returns {EventBuffer} returns the event buffer for chaining
+   * Add feature-processed event to our buffer. If this event would cause our total raw size to exceed the set max payload size, it is dropped.
+   * @param {any} event - any primitive type or object
+   * @returns {Boolean} true if successfully added; false otherwise
    */
   add(event) {
-    const size = (0, _stringify.stringify)(event).length;
-    if (!this.canMerge(size)) return this;
+    const addSize = (0, _stringify.stringify)(event)?.length || 0; // (estimate) # of bytes a directly stringified event it would take to send
+    if (this.#rawBytes + addSize > this.maxPayloadSize) return false;
     this.#buffer.push(event);
-    this.#bytes += size;
-    return this;
+    this.#rawBytes += addSize;
+    return true;
   }
 
   /**
-   * clear the buffer data
-   * @returns {EventBuffer}
+   * Wipes the main buffer
    */
   clear() {
-    this.#bytes = 0;
     this.#buffer = [];
-    return this;
-  }
-
-  /**
-   * Hold the buffer data in a new (child) EventBuffer (.held) to unblock the main buffer.
-   * This action clears the main buffer
-   * @returns {EventBuffer}
-   */
-  hold() {
-    this.held.merge(this);
-    this.clear();
-    return this;
+    this.#rawBytes = 0;
   }
 
   /**
-   * Prepend the held EventBuffer (.held) back into the main buffer
-   * This action clears the held buffer
-   * @returns {EventBuffer}
+   * Backup the buffered data and clear the main buffer
+   * @returns {Array} the events being backed up
    */
-  unhold() {
-    this.merge(this.held, true);
-    this.held.clear();
-    return this;
+  save() {
+    this.#bufferBackup = this.#buffer;
+    this.#rawBytesBackup = this.#rawBytes;
   }
 
   /**
-   * Merges an EventBuffer into this EventBuffer
-   * @param {EventBuffer} events an EventBuffer intended to merge with this EventBuffer
-   * @param {boolean} prepend if true, the supplied events will be prepended before the events of this class
-   * @returns {EventBuffer} returns the event buffer for chaining
+   * Wipes the backup buffer
    */
-  merge(eventBuffer, prepend = false) {
-    if (!this.canMerge(eventBuffer.bytes)) return this;
-    this.#buffer = prepend ? [...eventBuffer.buffer, ...this.#buffer] : [...this.#buffer, ...eventBuffer.buffer];
-    this.#bytes += eventBuffer.#bytes;
-    return this;
+  clearSave() {
+    this.#bufferBackup = undefined;
+    this.#rawBytesBackup = undefined;
   }
 
   /**
-   * Returns a boolean indicating the resulting size of a merge would be valid. Compares against the maxPayloadSize provided at initialization time.
-   * @param {number} size
-   * @returns {boolean}
+   * Prepend the backup buffer back into the main buffer
    */
-  canMerge(size) {
-    return this.bytes + (size || Infinity) < this.maxPayloadSize;
+  reloadSave() {
+    if (!this.#bufferBackup) return;
+    if (this.#rawBytesBackup + this.#rawBytes > this.maxPayloadSize) return;
+    this.#buffer = [...this.#bufferBackup, ...this.#buffer];
+    this.#rawBytes = this.#rawBytesBackup + this.#rawBytes;
   }
 }
 exports.EventBuffer = EventBuffer;

package/dist/cjs/features/utils/instrument-base.js

@@ -102,11 +102,11 @@ class InstrumentBase extends _featureBase.FeatureBase {
       try {
         // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
         if (!agentRef.sharedAggregator) {
-          agentRef.sharedAggregator = Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "shared-aggregator" */'../../common/aggregate/aggregator')));
+          agentRef.sharedAggregator = Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "shared-aggregator" */'../../common/aggregate/event-aggregator')));
           const {
-            Aggregator
+            EventAggregator
           } = await agentRef.sharedAggregator;
-          agentRef.sharedAggregator = new Aggregator();
+          agentRef.sharedAggregator = new EventAggregator();
         } else await agentRef.sharedAggregator; // if another feature is already importing the aggregator, wait for it to finish
 
         if (!this.#shouldImportAgg(this.featureName, session)) {

package/dist/cjs/loaders/features/features.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.featurePriority = exports.FEATURE_NAMES = void 0;
+exports.featurePriority = exports.FEATURE_TO_ENDPOINT = exports.FEATURE_NAMES = void 0;
 const FEATURE_NAMES = exports.FEATURE_NAMES = {
   ajax: 'ajax',
   genericEvents: 'generic_events',
@@ -38,4 +38,16 @@ const featurePriority = exports.featurePriority = {
   [FEATURE_NAMES.sessionReplay]: 9,
   [FEATURE_NAMES.logging]: 10,
   [FEATURE_NAMES.genericEvents]: 11
+};
+const FEATURE_TO_ENDPOINT = exports.FEATURE_TO_ENDPOINT = {
+  [FEATURE_NAMES.pageViewTiming]: 'events',
+  [FEATURE_NAMES.ajax]: 'events',
+  [FEATURE_NAMES.spa]: 'events',
+  [FEATURE_NAMES.softNav]: 'events',
+  [FEATURE_NAMES.metrics]: 'jserrors',
+  [FEATURE_NAMES.jserrors]: 'jserrors',
+  [FEATURE_NAMES.sessionTrace]: 'browser/blobs',
+  [FEATURE_NAMES.sessionReplay]: 'browser/blobs',
+  [FEATURE_NAMES.logging]: 'browser/logs',
+  [FEATURE_NAMES.genericEvents]: 'ins'
 };

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

@@ -2,11 +2,8 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import { SharedContext } from '../context/shared-context';
-export class Aggregator extends SharedContext {
-  constructor(parent) {
-    super(parent);
+export class Aggregator {
+  constructor() {
     this.aggregatedData = {};
   }
 
@@ -15,12 +12,14 @@ export class Aggregator extends 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;
@@ -45,11 +44,25 @@ export class Aggregator extends 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) {
@@ -62,26 +75,6 @@ export class Aggregator extends 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;
-  }
 }
 function aggregateMetrics(newMetrics, oldMetrics) {
   if (!oldMetrics) oldMetrics = {

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

@@ -0,0 +1,78 @@
+import { Aggregator } from './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.
+ */
+export class EventAggregator {
+  #aggregator = new 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];
+  }
+}

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

@@ -72,9 +72,6 @@ const model = () => {
     page_action: {
       enabled: true
     },
-    user_actions: {
-      enabled: true
-    },
     page_view_event: {
       enabled: true,
       autoStart: true
@@ -84,6 +81,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
     },
@@ -167,7 +168,10 @@ const model = () => {
       harvestTimeSeconds: 10,
       autoStart: true
     },
-    ssl: undefined
+    ssl: undefined,
+    user_actions: {
+      enabled: true
+    }
   };
 };
 const _cache = {};

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.271.0";
+export const VERSION = "1.273.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.271.0";
+export const VERSION = "1.273.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -95,7 +95,7 @@ export class HarvestScheduler extends 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/esm/common/harvest/harvest.js

@@ -120,11 +120,7 @@ export class Harvest extends 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 = stringify(body);
-      }
+      if (endpoint !== 'events') body = 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) warn(28, endpoint);
     }

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

@@ -12,7 +12,6 @@
  * @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/esm/features/ajax/aggregate/index.js

@@ -8,44 +8,41 @@ import { handle } from '../../../common/event-emitter/handle';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list';
 import { FEATURE_NAME } from '../constants';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { parseGQL } from './gql';
-import { getNREUMInitializedAgent } from '../../../common/window/nreum';
-import Chunk from './chunk';
-import { EventBuffer } from '../../utils/event-buffer';
+import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
     const harvestTimeSeconds = agentRef.init.ajax.harvestTimeSeconds || 10;
     setDenyList(agentRef.runtime.denyList);
-    this.ajaxEvents = new 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
-    registerHandler('returnAjax', event => this.ajaxEvents.add(event), this.featureName, this.ee);
+    registerHandler('returnAjax', event => this.events.add(event), this.featureName, this.ee);
     // --- ^
     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('events', {
-        onFinished: this.onEventsHarvestFinished.bind(this),
-        getPayload: this.prepareHarvest.bind(this)
+      const scheduler = new HarvestScheduler(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();
@@ -63,10 +60,11 @@ export class Aggregate extends AggregateBase {
     }
     const shouldCollect = shouldCollectEvent(params);
     const shouldOmitAjaxMetrics = this.agentRef.init.feature_flags?.includes('ajax_metrics_deny_list');
+    const jserrorsInUse = Boolean(this.agentRef.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) {
@@ -105,62 +103,55 @@ export class Aggregate extends AggregateBase {
       query: ctx.parsedOrigin?.search
     });
     if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, this.ee);
-    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features?.[FEATURE_NAMES.softNav]);
+    const softNavInUse = Boolean(this.agentRef.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
       handle('ajax', [event], undefined, 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();
-      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(arr.slice(i, i + chunkSize), this));
+  serializer(eventBuffer) {
+    const addString = getAddStringContext(this.agentIdentifier);
+    let payload = 'bel.7;';
+    for (let i = 0; i < eventBuffer.length; i++) {
+      const event = eventBuffer[i];
+      const fields = [numeric(event.startTime), numeric(event.endTime - event.startTime), numeric(0),
+      // callbackEnd
+      numeric(0),
+      // no callbackDuration for non-SPA events
+      addString(event.method), numeric(event.status), addString(event.domain), addString(event.path), numeric(event.requestSize), numeric(event.responseSize), event.type === 'fetch' ? 1 : '', addString(0),
+      // nodeId
+      nullable(event.spanId, addString, true) +
+      // guid
+      nullable(event.traceId, addString, true) +
+      // traceId
+      nullable(event.spanTimestamp, 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 = addCustomAttributes({
+        ...(jsAttributes || {}),
+        ...(event.gql || {})
+      }, addString);
+      fields.unshift(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;
   }
 }