@newrelic/browser-agent 1.263.0 → 1.265.0

package/dist/cjs/common/window/page-visibility.js

@@ -15,10 +15,7 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-function subscribeToVisibilityChange(cb) {
-  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  let capture = arguments.length > 2 ? arguments[2] : undefined;
-  let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
+function subscribeToVisibilityChange(cb, toHiddenOnly = false, capture, abortSignal) {
   (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange, capture, abortSignal);
   function handleVisibilityChange() {
     if (toHiddenOnly) {

package/dist/cjs/common/wrap/wrap-events.js

@@ -83,14 +83,11 @@ function wrapEvents(sharedEE) {
  * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg
  * @param {Array} rest - [optional] any additional arguments to pass to the cb
  */
-function findEventListenerProtoAndCb(object, cb) {
+function findEventListenerProtoAndCb(object, cb, ...rest) {
   let step = object;
   while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {
     step = Object.getPrototypeOf(step);
   }
-  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    rest[_key - 2] = arguments[_key];
-  }
   if (step) cb(step, ...rest);
 }
 

package/dist/cjs/common/wrap/wrap-promise.js

@@ -111,13 +111,10 @@ function wrapPromise(sharedEE) {
 
     // Note that this wrapping affects the same originals.PR (prototype) object.
     const prevPromiseOrigThen = prevPromiseObj.prototype.then;
-    prevPromiseObj.prototype.then = function wrappedThen() {
+    prevPromiseObj.prototype.then = function wrappedThen(...args) {
       var originalThis = this;
       var ctx = getContext(originalThis);
       ctx.promise = originalThis;
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
       args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);
       args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);
       const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);

package/dist/cjs/common/wrap/wrap-websocket.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WEBSOCKET_TAG = exports.ADD_EVENT_LISTENER_TAG = void 0;
+exports.wrapWebSocket = wrapWebSocket;
+var _runtime = require("../constants/runtime");
+var _now = require("../timing/now");
+var _load = require("../window/load");
+var _uniqueId = require("../ids/unique-id");
+var _nreum = require("../window/nreum");
+const WEBSOCKET_TAG = exports.WEBSOCKET_TAG = 'websocket-';
+const ADD_EVENT_LISTENER_TAG = exports.ADD_EVENT_LISTENER_TAG = 'addEventListener';
+const wrapped = {};
+function wrapWebSocket(sharedEE) {
+  if (wrapped[sharedEE.debugId]++) return sharedEE;
+  const originals = (0, _nreum.gosNREUMOriginals)().o;
+  if (!originals.WS) return sharedEE;
+  function reporter(socketId) {
+    const createdAt = (0, _now.now)();
+    return function (message, ...data) {
+      const timestamp = data[0]?.timeStamp || (0, _now.now)();
+      const isLoaded = (0, _load.checkState)();
+      sharedEE.emit(WEBSOCKET_TAG + message, [timestamp, timestamp - createdAt, isLoaded, socketId, ...data]);
+    };
+  }
+  Object.defineProperty(WrappedWebSocket, 'name', {
+    value: 'WebSocket'
+  });
+  function WrappedWebSocket() {
+    const ws = new originals.WS(...arguments);
+    const socketId = (0, _uniqueId.generateRandomHexString)(6);
+    const report = reporter(socketId);
+    report('new');
+    const events = ['message', 'error', 'open', 'close'];
+    /** add event listeners */
+    events.forEach(evt => {
+      ws.addEventListener(evt, function (e) {
+        report(ADD_EVENT_LISTENER_TAG, {
+          eventType: evt,
+          event: e
+        });
+      });
+    })
+
+    /** could also observe the on-events for runtime processing, but not implemented yet */
+
+    /** observe the static method send, but noteably not close, as that is currently observed with the event listener */;
+    ['send'].forEach(wrapStaticProperty);
+    function wrapStaticProperty(prop) {
+      const originalProp = ws[prop];
+      if (originalProp) {
+        Object.defineProperty(proxiedProp, 'name', {
+          value: prop
+        });
+        function proxiedProp() {
+          report(prop, ...arguments);
+          try {
+            return originalProp.apply(this, arguments);
+          } catch (err) {
+            report(prop + '-err', ...arguments);
+            // rethrow error so we don't effect execution by observing.
+            throw err;
+          }
+        }
+        ws[prop] = proxiedProp;
+      }
+    }
+    return ws;
+  }
+  _runtime.globalScope.WebSocket = WrappedWebSocket;
+  return sharedEE;
+}

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

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _belSerializer = require("../../../common/serialize/bel-serializer");
-var _config = require("../../../common/config/config");
+var _info = require("../../../common/config/info");
+var _agentConstants = require("../../../common/constants/agent-constants");
 class Chunk {
   constructor(events, aggregateInstance) {
     this.addString = (0, _belSerializer.getAddStringContext)(aggregateInstance.agentIdentifier); // pass agentIdentifier here
@@ -28,7 +29,7 @@ class Chunk {
       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 = (0, _config.getInfo)(aggregateInstance.agentIdentifier).jsAttributes;
+      const jsAttributes = (0, _info.getInfo)(aggregateInstance.agentIdentifier).jsAttributes;
 
       // add custom attributes
       // gql decorators are added as custom attributes to alleviate need for new BEL schema
@@ -44,7 +45,7 @@ class Chunk {
       if (i + 1 < events.length) insert += ';';
       this.payload += insert;
     }
-    this.tooBig = this.payload.length * 2 > aggregateInstance.MAX_PAYLOAD_SIZE;
+    this.tooBig = this.payload.length * 2 > _agentConstants.MAX_PAYLOAD_SIZE;
   }
 }
 exports.default = Chunk;

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

@@ -19,11 +19,10 @@ var _typeCheck = require("../../../common/util/type-check");
  * @param {string} query Ajax request query param string
  * @returns {GQLMetadata | undefined}
  */
-function parseGQL() {
-  let {
-    body,
-    query
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function parseGQL({
+  body,
+  query
+} = {}) {
   if (!body && !query) return;
   try {
     const gqlBody = parseBatchGQL(parseGQLContents(body));

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

@@ -7,7 +7,9 @@ exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _stringify = require("../../../common/util/stringify");
 var _handle = require("../../../common/event-emitter/handle");
-var _config = require("../../../common/config/config");
+var _info = require("../../../common/config/info");
+var _init = require("../../../common/config/init");
+var _runtime = require("../../../common/config/runtime");
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _denyList = require("../../../common/deny-list/deny-list");
 var _constants = require("../constants");
@@ -17,6 +19,7 @@ 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 }; }
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -30,29 +33,27 @@ class Aggregate extends _aggregateBase.AggregateBase {
   #agentInit;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
-    this.#agentInfo = (0, _config.getInfo)(agentIdentifier);
-    this.#agentRuntime = (0, _config.getRuntime)(agentIdentifier);
-    this.#agentInit = (0, _config.getConfiguration)(agentIdentifier);
+    this.#agentInfo = (0, _info.getInfo)(agentIdentifier);
+    this.#agentRuntime = (0, _runtime.getRuntime)(agentIdentifier);
+    this.#agentInit = (0, _init.getConfiguration)(agentIdentifier);
     const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10;
-    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000;
     (0, _denyList.setDenyList)(this.#agentRuntime.denyList);
-    this.ajaxEvents = [];
+    this.ajaxEvents = new _eventBuffer.EventBuffer();
     this.spaAjaxEvents = {};
-    this.sentAjaxEvents = [];
     const classThis = this;
 
     // --- v Used by old spa feature
     this.ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!this.spaAjaxEvents[interaction.id]) return;
+      if (!this.spaAjaxEvents[interaction.id]?.hasData) 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.spaAjaxEvents[interaction.id].forEach(item => this.ajaxEvents.push(item));
+        this.ajaxEvents.merge(this.spaAjaxEvents[interaction.id]);
       }
       delete this.spaAjaxEvents[interaction.id];
     });
     // --- ^
     // --- v Used by new soft nav
-    (0, _registerHandler.registerHandler)('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('returnAjax', event => this.ajaxEvents.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.
@@ -112,7 +113,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (ctx.dt) {
       event.spanId = ctx.dt.spanId;
       event.traceId = ctx.dt.traceId;
-      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp);
+      event.spanTimestamp = Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp));
     }
 
     // parsed from the AJAX body, looking for operationName param & parsing query for operationType
@@ -128,31 +129,27 @@ class Aggregate extends _aggregateBase.AggregateBase {
     } 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] = this.spaAjaxEvents[interactionId] || [];
-      this.spaAjaxEvents[interactionId].push(event);
+      this.spaAjaxEvents[interactionId] ??= new _eventBuffer.EventBuffer();
+      this.spaAjaxEvents[interactionId].add(event);
     } else {
-      this.ajaxEvents.push(event);
+      this.ajaxEvents.add(event);
     }
   }
   prepareHarvest(options) {
     options = options || {};
-    if (this.ajaxEvents.length === 0) return null;
-    const payload = this.#getPayload(this.ajaxEvents);
+    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.sentAjaxEvents = this.ajaxEvents;
-    this.ajaxEvents = [];
+    if (options.retry) this.ajaxEvents.hold();else this.ajaxEvents.clear();
     return payloadObjs;
   }
   onEventsHarvestFinished(result) {
-    if (result.retry && this.sentAjaxEvents.length > 0) {
-      this.ajaxEvents.unshift(...this.sentAjaxEvents);
-      this.sentAjaxEvents = [];
-    }
+    if (result.retry && this.ajaxEvents.held.hasData) this.ajaxEvents.unhold();else this.ajaxEvents.held.clear();
   }
   #getPayload(events, numberOfChunks) {
     numberOfChunks = numberOfChunks || 1;

package/dist/cjs/features/ajax/constants.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MAX_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
+exports.FEATURE_NAME = void 0;
 var _features = require("../../loaders/features/features");
-const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;
-const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;

package/dist/cjs/features/ajax/instrument/distributed-tracing.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DT = void 0;
-var _config = require("../../../common/config/config");
+var _init = require("../../../common/config/init");
+var _loaderConfig = require("../../../common/config/loader-config");
 var _uniqueId = require("../../../common/ids/unique-id");
 var _parseUrl = require("../../../common/url/parse-url");
 var _runtime = require("../../../common/constants/runtime");
@@ -22,7 +23,7 @@ class DT {
     if (!this.shouldGenerateTrace(parsedOrigin)) {
       return null;
     }
-    var loaderConfig = (0, _config.getLoaderConfig)(this.agentIdentifier);
+    var loaderConfig = (0, _loaderConfig.getLoaderConfig)(this.agentIdentifier);
     if (!loaderConfig) {
       return null;
     }
@@ -90,9 +91,9 @@ class DT {
   isAllowedOrigin(parsedOrigin) {
     var allowed = false;
     var dtConfig = {};
-    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    var dt = (0, _init.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
     if (dt) {
-      dtConfig = (0, _config.getConfiguration)(this.agentIdentifier).distributed_tracing;
+      dtConfig = (0, _init.getConfiguration)(this.agentIdentifier).distributed_tracing;
     }
     if (parsedOrigin.sameOrigin) {
       allowed = true;
@@ -108,7 +109,7 @@ class DT {
     return allowed;
   }
   isDtEnabled() {
-    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    var dt = (0, _init.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
     if (dt) {
       return !!dt.enabled;
     }
@@ -117,21 +118,21 @@ class DT {
 
   // exclude the newrelic header for same-origin calls
   excludeNewrelicHeader() {
-    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    var dt = (0, _init.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
     if (dt) {
       return !!dt.exclude_newrelic_header;
     }
     return false;
   }
   useNewrelicHeaderForCors() {
-    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    var dt = (0, _init.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
     if (dt) {
       return dt.cors_use_newrelic_header !== false;
     }
     return false;
   }
   useTraceContextHeadersForCors() {
-    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    var dt = (0, _init.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
     if (dt) {
       return !!dt.cors_use_tracecontext_headers;
     }

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

@@ -3,14 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Instrument = void 0;
-var _config = require("../../../common/config/config");
+exports.Instrument = exports.Ajax = void 0;
+var _nreum = require("../../../common/window/nreum");
+var _loaderConfig = require("../../../common/config/loader-config");
 var _handle = require("../../../common/event-emitter/handle");
 var _id = require("../../../common/ids/id");
 var _runtime = require("../../../common/constants/runtime");
 var _dataSize = require("../../../common/util/data-size");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
-var _wrap = require("../../../common/wrap");
+var _wrapXhr = require("../../../common/wrap/wrap-xhr");
+var _wrapFetch = require("../../../common/wrap/wrap-fetch");
 var _parseUrl = require("../../../common/url/parse-url");
 var _distributedTracing = require("./distributed-tracing");
 var _responseSize = require("./response-size");
@@ -27,12 +29,11 @@ var _denyList = require("../../../common/deny-list/deny-list");
 
 var handlers = ['load', 'error', 'abort', 'timeout'];
 var handlersLen = handlers.length;
-var origRequest = _config.originals.REQ;
-var origXHR = _config.originals.XHR;
+var origRequest = (0, _nreum.gosNREUMOriginals)().o.REQ;
+var origXHR = (0, _nreum.gosNREUMOriginals)().o.XHR;
 class Instrument extends _instrumentBase.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.dt = new _distributedTracing.DT(agentIdentifier);
     this.handler = (type, args, ctx, group) => (0, _handle.handle)(type, args, ctx, group, this.ee);
@@ -68,8 +69,8 @@ class Instrument extends _instrumentBase.InstrumentBase {
     } catch (err) {
       // do nothing
     }
-    (0, _wrap.wrapFetch)(this.ee);
-    (0, _wrap.wrapXhr)(this.ee);
+    (0, _wrapFetch.wrapFetch)(this.ee);
+    (0, _wrapXhr.wrapXhr)(this.ee);
     subscribeToEvents(agentIdentifier, this.ee, this.handler, this.dt);
     this.importAggregator();
   }
@@ -128,7 +129,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
     this.metrics = {};
   }
   function onOpenXhrEnd(args, xhr) {
-    var loaderConfig = (0, _config.getLoaderConfig)(agentIdentifier);
+    var loaderConfig = (0, _loaderConfig.getLoaderConfig)(agentIdentifier);
     if (loaderConfig.xpid && this.sameOrigin) {
       xhr.setRequestHeader('X-NewRelic-ID', loaderConfig.xpid);
     }
@@ -347,7 +348,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
     if ((0, _denyList.hasUndefinedHostname)(params)) return; // don't bother with XHR of url with no hostname
 
     metrics.duration = (0, _now.now)() - this.startTime;
-    if (!this.loadCaptureCalled && xhr.readyState === 4) {
+    if (!this.loadCazptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr);
     } else if (params.status == null) {
       params.status = 0;
@@ -381,4 +382,5 @@ function addUrl(ctx, url) {
   params.pathname = parsed.pathname;
   ctx.parsedOrigin = parsed;
   ctx.sameOrigin = parsed.sameOrigin;
-}
+}
+const Ajax = exports.Ajax = Instrument;

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _stringify = require("../../../common/util/stringify");
+var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
+var _cleanUrl = require("../../../common/url/clean-url");
+var _info = require("../../../common/config/info");
+var _init = require("../../../common/config/init");
+var _runtime = require("../../../common/config/runtime");
+var _constants = require("../constants");
+var _runtime2 = require("../../../common/constants/runtime");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _console = require("../../../common/util/console");
+var _now = require("../../../common/timing/now");
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _drain = require("../../../common/drain/drain");
+var _constants2 = require("../../metrics/constants");
+var _eventBuffer = require("../../utils/event-buffer");
+var _traverse = require("../../../common/util/traverse");
+var _agentConstants = require("../../../common/constants/agent-constants");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Aggregate extends _aggregateBase.AggregateBase {
+  #agentRuntime;
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+    this.eventsPerHarvest = 1000;
+    this.harvestTimeSeconds = (0, _init.getConfigurationValue)(this.agentIdentifier, 'generic_events.harvestTimeSeconds');
+    this.referrerUrl = _runtime2.isBrowserScope && document.referrer ? (0, _cleanUrl.cleanURL)(document.referrer) : undefined;
+    this.events = new _eventBuffer.EventBuffer();
+    this.#agentRuntime = (0, _runtime.getRuntime)(this.agentIdentifier);
+    this.waitForFlags(['ins']).then(([ins]) => {
+      if (!ins) {
+        this.blocked = true;
+        (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
+        return;
+      }
+      if ((0, _init.getConfigurationValue)(this.agentIdentifier, 'page_action.enabled')) {
+        (0, _registerHandler.registerHandler)('api-addPageAction', (timestamp, name, attributes) => {
+          this.addEvent({
+            ...attributes,
+            eventType: 'PageAction',
+            timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp))),
+            timeSinceLoad: timestamp / 1000,
+            actionName: name,
+            referrerUrl: this.referrerUrl,
+            currentUrl: (0, _cleanUrl.cleanURL)('' + location),
+            ...(_runtime2.isBrowserScope && {
+              browserWidth: window.document.documentElement?.clientWidth,
+              browserHeight: window.document.documentElement?.clientHeight
+            })
+          });
+        }, this.featureName, this.ee);
+      }
+      this.harvestScheduler = new _harvestScheduler.HarvestScheduler('ins', {
+        onFinished: (...args) => this.onHarvestFinished(...args)
+      }, this);
+      this.harvestScheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args));
+      this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
+      this.drain();
+    });
+  }
+
+  // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
+  addEvent(obj = {}) {
+    if (!obj || !Object.keys(obj).length) return;
+    if (!obj.eventType) {
+      (0, _console.warn)(44);
+      return;
+    }
+    for (let key in obj) {
+      let val = obj[key];
+      obj[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+    }
+    const defaultEventAttributes = {
+      /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
+      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp((0, _now.now)()))),
+      /** all generic events require a pageUrl */
+      pageUrl: (0, _cleanUrl.cleanURL)((0, _runtime.getRuntime)(this.agentIdentifier).origin)
+    };
+    const eventAttributes = {
+      /** Agent-level custom attributes */
+      ...((0, _info.getInfo)(this.agentIdentifier).jsAttributes || {}),
+      /** Fallbacks for required properties in-case the event did not supply them, should take precedence over agent-level custom attrs */
+      ...defaultEventAttributes,
+      /** Event-specific attributes take precedence over agent-level custom attributes and fallbacks */
+      ...obj
+    };
+    this.events.add(eventAttributes);
+    this.checkEventLimits();
+  }
+  onHarvestStarted(options) {
+    const {
+      userAttributes,
+      atts
+    } = (0, _info.getInfo)(this.agentIdentifier);
+    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();
+    return payload;
+  }
+  onHarvestFinished(result) {
+    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold();else this.events.held.clear();
+  }
+  checkEventLimits() {
+    // check if we've reached any harvest limits...
+    if (this.events.bytes > _agentConstants.IDEAL_PAYLOAD_SIZE) {
+      this.ee.emit(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen']);
+      this.harvestScheduler.runHarvest();
+    }
+  }
+}
+exports.Aggregate = Aggregate;

package/dist/cjs/features/generic_events/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
+var _features = require("../../loaders/features/features");
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.genericEvents;
+const IDEAL_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = 64000;
+const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GenericEvents", {
+  enumerable: true,
+  get: function () {
+    return _index.Instrument;
+  }
+});
+var _index = require("./instrument/index");

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = exports.GenericEvents = void 0;
+var _init = require("../../../common/config/init");
+var _drain = require("../../../common/drain/drain");
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../constants");
+/* Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
+    const genericEventSourceConfigs = [(0, _init.getConfigurationValue)(this.agentIdentifier, 'page_action.enabled')
+    // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
+    ];
+    /** If any of the sources are active, import the aggregator. otherwise deregister */
+    if (genericEventSourceConfigs.some(x => x)) this.importAggregator();else (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
+  }
+}
+exports.Instrument = Instrument;
+const GenericEvents = exports.GenericEvents = Instrument;