@newrelic/browser-agent 1.282.0 → 1.283.0

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

@@ -3,12 +3,94 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FEATURE_FLAGS } from '../../features/generic_events/constants';
-import { LOG_LEVELS } from '../../features/logging/constants';
 import { isValidSelector } from '../dom/query-selector';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../session/constants';
 import { warn } from '../util/console';
 import { getNREUMInitializedAgent } from '../window/nreum';
 import { getModeledObject } from './configurable';
+
+/**
+ * @typedef {Object} Init
+ * @property {Object} [ajax]
+ * @property {Array<string>} [ajax.deny_list] - List of domain URLs to be excluded from AjaxRequest collection.
+ * @property {boolean} [ajax.block_internal] - If true, agent requests going to harvest endpoint are treated as on deny list. In other words, agent will not self-report AJAX.
+ * @property {boolean} [ajax.enabled] - Turn on/off the ajax feature (on by default).
+ * @property {boolean} [ajax.autoStart] - If true, the agent will automatically start the ajax feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [distributed_tracing]
+ * @property {boolean} [distributed_tracing.enabled] - If true, distributed tracing headers will be added to outgoing requests. Requires ajax feature to be running.
+ * @property {boolean} [distributed_tracing.exclude_newrelic_header]
+ * @property {boolean} [distributed_tracing.cors_use_newrelic_header]
+ * @property {boolean} [distributed_tracing.cors_use_tracecontext_headers]
+ * @property {Array<string>} [distributed_tracing.allowed_origins]
+ * @property {Array<string>} [feature_flags] - An array of feature flags to enable experimental features.
+ * @property {Object} [generic_events]
+ * @property {boolean} [generic_events.enabled] - Turn on/off the generic events feature (on by default). This is required for `PageAction`, `UserAction`, and `BrowserPerformance` events.
+ * @property {boolean} [generic_events.autoStart] - If true, the agent will automatically start the generic events feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [harvest]
+ * @property {number} [harvest.interval] - The interval in seconds at which the agent will send out data. It's not recommended to change this value.
+ * @property {Object} [jserrors]
+ * @property {boolean} [jserrors.enabled] - Turn on/off the jserrors feature (on by default).
+ * @property {boolean} [jserrors.autoStart] - If true, the agent will automatically start the jserrors feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [logging]
+ * @property {boolean} [logging.enabled] - Turn on/off the logging feature (on by default).
+ * @property {boolean} [logging.autoStart] - If true, the agent will automatically start the logging feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [metrics]
+ * @property {boolean} [metrics.enabled] - Turn on/off the metrics feature (on by default).
+ * @property {boolean} [metrics.autoStart] - If true, the agent will automatically start the metrics feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Array<Object>} [obfuscate] - Array of regexp and corresponding replacement patterns for obfuscating data.
+ * @property {Object} [page_action]
+ * @property {boolean} [page_action.enabled] - Must be true to allow PageAction events to be captured.
+ * @property {Object} [page_view_event]
+ * @property {boolean} [page_view_event.enabled] - This setting is ignored! PageViewEvent is always enabled by force.
+ * @property {boolean} [page_view_event.autoStart] - If true, the agent will automatically send the RUM request. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [page_view_timing]
+ * @property {boolean} [page_view_timing.enabled] - Turn on/off the page view timing feature (on by default).
+ * @property {boolean} [page_view_timing.autoStart] - If true, the agent will automatically start the page view timing feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [performance]
+ * @property {boolean} [performance.capture_marks] - If true, the agent will capture PerformanceMark events.
+ * @property {boolean} [performance.capture_measures] - If true, the agent will capture PerformanceMeasure events.
+ * @property {boolean} [performance.capture_detail] - If true, `BrowserPerformance` events from marks and measures will include, as attribute(s), the `detail` metadata provided to `markOptions` and `measureOptions`.
+ * @property {Object} [performance.resources]
+ * @property {boolean} [performance.resources.enabled] - If true, the agent will capture PerformanceResourceTiming entries.
+ * @property {Array<string>} [performance.resources.asset_types] - Array of `initiatorType` strings to filter the desired ResourceTiming entries. By default, all resource types are captured.
+ * @property {Array<string>} [performance.resources.first_party_domains] - Each resource URL will be checked against this list to determine if it should be labeled "first party" in the resulting `BrowserPerformance` event.
+ * @property {boolean} [performance.resources.ignore_newrelic] - When true (default), resource entries associated with New Relic domains will be ignored.
+ * @property {Object} [privacy]
+ * @property {boolean} [privacy.cookies_enabled] - If true (default), session tracking of users across page loads is enabled in the agent. This is required for session trace, replay, and session-related features.
+ * @property {Object} [proxy]
+ * @property {string} [proxy.assets] - Set value will be used to overwrite the webpack asset path used to fetch agent assets.
+ * @property {string} [proxy.beacon] - Set value will be used to overwrite the endpoint URL to which we send analytics.
+ * @property {Object} [session]
+ * @property {number} [session.expiresMs] - When session tracking is on, this determines how long a session will last before expiring. Modifying this value is not recommended.
+ * @property {number} [session.inactiveMs] - When session tracking is on, this determines how long a session will last without user activity before expiring. Modifying this value is not recommended.
+ * @property {Object} [session_replay]
+ * @property {boolean} [session_replay.autoStart] - If true, the agent will automatically start the session replay feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {boolean} [session_replay.enabled] - Turn on/off the session replay feature (off by default).
+ * @property {boolean} [session_replay.preload] - If true, allow the agent to run rrweb recorder immediately instead of waiting until after the window.load event, for new sessions. Existing sessions ignore this setting.
+ * @property {number} [session_replay.sampling_rate] - This setting is deprecated and ineffective. Sampling is controlled in New Relic by server-side configuration.
+ * @property {number} [session_replay.error_sampling_rate] - This setting is deprecated and ineffective.
+ * @property {boolean} [session_replay.collect_fonts] - When true, serialize fonts for collection without public asset url. This is currently broken -- https://github.com/rrweb-io/rrweb/issues/1304.
+ * @property {boolean} [session_replay.inline_images] - When true, serialize images for collection without public asset url. Not recommended for use. This is currently for TESTING as it easily generates payloads too large to be harvested.
+ * @property {boolean} [session_replay.fix_stylesheets] - When true, tries to fetch any missing stylesheets again to inline in replayer.
+ * @property {boolean} [session_replay.mask_all_inputs] - If true, all input content will be masked with asterisks.
+ * @property {string} [session_replay.mask_text_selector] - Set value should be in CSS selector syntax and is used to identify matching elements to mask.
+ * @property {string} [session_replay.block_selector] - Set value should be in CSS selector syntax and is used to identify matching elements to block.
+ * @property {Object} [session_replay.mask_input_options] - If mask_all_inputs is not true, this object will be used to select what input to mask. Passwords are forcibly always masked.
+ * @property {Object} [session_trace]
+ * @property {boolean} [session_trace.enabled] - Turn on/off the session trace feature (on by default).
+ * @property {boolean} [session_trace.autoStart] - If true, the agent will automatically start the session trace feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [soft_navigations]
+ * @property {boolean} [soft_navigations.enabled] - Turn on/off the soft navigations feature (on by default).
+ * @property {boolean} [soft_navigations.autoStart] - If true, the agent will automatically start the soft navigations feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {Object} [spa]
+ * @property {boolean} [spa.enabled] - Turn on/off the single page application feature (on by default). NOTE: the SPA feature is deprecated and under removal procedure.
+ * @property {boolean} [spa.autoStart] - If true, the agent will automatically start the single page application feature. Otherwise, it will be in a deferred state until the `start` API method is called.
+ * @property {boolean} [ssl] - If explicitly false, the agent will use HTTP instead of HTTPS. This setting should NOT be used.
+ * @property {Object} [user_actions]
+ * @property {boolean} [user_actions.enabled] - Must be true to allow UserAction events to be captured.
+ * @property {Array<string>} [user_actions.elementAttributes] - List of HTML Element properties to be captured with UserAction events' target elements. This may help to identify the source element being interacted with in the UI.
+ */
+
 const nrMask = '[data-nr-mask]';
 const model = () => {
   const hiddenState = {
@@ -73,8 +155,7 @@ const model = () => {
     },
     logging: {
       enabled: true,
-      autoStart: true,
-      level: LOG_LEVELS.INFO
+      autoStart: true
     },
     metrics: {
       enabled: true,
@@ -107,7 +188,6 @@ const model = () => {
       },
       capture_detail: true,
       resources: {
-        // whether to run this subfeature or not in the generic_events feature. false by default through experimental phase, but flipped to true once GA'd
         get enabled() {
           return hiddenState.feature_flags.includes(FEATURE_FLAGS.RESOURCES) || hiddenState.experimental.resources;
         },
@@ -115,41 +195,30 @@ const model = () => {
           hiddenState.experimental.resources = val;
         },
         asset_types: [],
-        // MDN types to collect, empty array will collect all types
         first_party_domains: [],
-        // when included, will decorate the resource as first party if matching
-        ignore_newrelic: true // ignore capturing internal agent scripts and harvest calls
+        ignore_newrelic: true
       }
     },
     privacy: {
       cookies_enabled: true
     },
-    // *cli - per discussion, default should be true
     proxy: {
       assets: undefined,
-      // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
-      beacon: undefined // likewise for the url to which we send analytics
+      beacon: undefined
     },
     session: {
       expiresMs: DEFAULT_EXPIRES_MS,
       inactiveMs: DEFAULT_INACTIVE_MS
     },
     session_replay: {
-      // feature settings
       autoStart: true,
       enabled: false,
       preload: false,
-      // if true, enables the agent to load rrweb immediately instead of waiting to do so after the window.load event
       sampling_rate: 10,
-      // float from 0 - 100
       error_sampling_rate: 100,
-      // float from 0 - 100
       collect_fonts: false,
-      // serialize fonts for collection without public asset url, this is currently broken in RRWeb -- https://github.com/rrweb-io/rrweb/issues/1304.  When fixed, revisit with test cases
       inline_images: false,
-      // serialize images for collection without public asset url -- right now this is only useful for testing as it easily generates payloads too large to be harvested
       fix_stylesheets: true,
-      // fetch missing stylesheet resources for inlining
       // recording config settings
       mask_all_inputs: true,
       // this has a getter/setter to facilitate validation of the selectors

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.282.0";
+export const VERSION = "1.283.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.282.0";
+export const VERSION = "1.283.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/session/session-entity.js

@@ -16,6 +16,7 @@ import { handle } from '../event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 import { windowAddEventListener } from '../event-listener/event-listener-opts';
+import { LOGGING_MODE } from '../../features/logging/constants';
 
 // this is what can be stored in local storage (not enforced but probably should be)
 // these values should sync between local storage and the parent class props
@@ -28,6 +29,7 @@ const model = {
   sessionReplaySentFirstChunk: false,
   sessionTraceMode: MODE.OFF,
   traceHarvestStarted: false,
+  loggingMode: LOGGING_MODE.OFF,
   serverTimeDiff: null,
   // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {}

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

@@ -8,18 +8,43 @@ import { warn } from '../../../common/util/console';
 import { stringify } from '../../../common/util/stringify';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
-import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
+import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS, LOGGING_MODE } from '../constants';
 import { Log } from '../shared/log';
 import { isValidLogLevel } from '../shared/utils';
 import { applyFnToProps } from '../../../common/util/traverse';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/constants';
+import { ABORT_REASONS } from '../../session_replay/constants';
+import { canEnableSessionTracking } from '../../utils/feature-gates';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
+    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session;
+
+    // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
+    this.ee.on(SESSION_EVENTS.RESET, () => {
+      this.abort(ABORT_REASONS.RESET);
+    });
+    this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+      if (this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
+      if (this.mode !== LOGGING_MODE.OFF && data.loggingMode === LOGGING_MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);else this.mode = data.loggingMode;
+    });
     this.harvestOpts.raw = true;
-    this.waitForFlags([]).then(() => {
+    this.waitForFlags(['log']).then(([loggingMode]) => {
+      const session = this.agentRef.runtime.session ?? {};
+      if (this.loggingMode === LOGGING_MODE.OFF || session.isNew && loggingMode === LOGGING_MODE.OFF) {
+        this.blocked = true;
+        this.deregisterDrain();
+        return;
+      }
+      if (session.isNew || !this.isSessionTrackingEnabled) {
+        this.updateLoggingMode(loggingMode);
+      } else {
+        this.loggingMode = session.state.loggingMode;
+      }
+
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
       registerHandler(LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee);
       this.drain();
@@ -27,11 +52,18 @@ export class Aggregate extends AggregateBase {
       agentRef.runtime.harvester.triggerHarvestFor(this);
     });
   }
+  updateLoggingMode(loggingMode) {
+    this.loggingMode = loggingMode;
+    this.syncWithSessionManager({
+      loggingMode: this.loggingMode
+    });
+  }
   handleLog(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
-    if (this.blocked) return;
+    if (this.blocked || !this.loggingMode) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
     if (typeof level === 'string') level = level.toUpperCase();
     if (!isValidLogLevel(level)) return warn(30, level);
+    if (this.loggingMode < (LOGGING_MODE[level] || Infinity)) return;
     try {
       if (typeof message !== 'string') {
         const stringified = stringify(message);
@@ -93,7 +125,9 @@ export class Aggregate extends AggregateBase {
           // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
           'instrumentation.provider': 'browser',
           'instrumentation.version': this.agentRef.runtime.version,
-          'instrumentation.name': this.agentRef.runtime.loaderType
+          'instrumentation.name': this.agentRef.runtime.loaderType,
+          // Custom attributes
+          ...this.agentRef.info.jsAttributes
         }
       },
       /** logs section contains individual unique log entries */
@@ -105,4 +139,19 @@ export class Aggregate extends AggregateBase {
       browser_monitoring_key: this.agentRef.info.licenseKey
     };
   }
+
+  /** Abort the feature, once aborted it will not resume */
+  abort(reason = {}) {
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ["Logging/Abort/".concat(reason.sm)], undefined, FEATURE_NAMES.logging, this.ee);
+    this.blocked = true;
+    this.events.clear();
+    this.events.clearSave();
+    this.updateLoggingMode(LOGGING_MODE.OFF);
+    this.deregisterDrain();
+  }
+  syncWithSessionManager(state = {}) {
+    if (this.isSessionTrackingEnabled) {
+      this.agentRef.runtime.session.write(state);
+    }
+  }
 }

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

@@ -10,5 +10,13 @@ export const LOG_LEVELS = {
   DEBUG: 'DEBUG',
   TRACE: 'TRACE'
 };
+export const LOGGING_MODE = {
+  OFF: 0,
+  ERROR: 1,
+  WARN: 2,
+  INFO: 3,
+  DEBUG: 4,
+  TRACE: 5
+};
 export const LOGGING_EVENT_EMITTER_CHANNEL = 'log';
 export const FEATURE_NAME = FEATURE_NAMES.logging;

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

@@ -5,11 +5,31 @@
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME } from '../constants';
 import { bufferLog } from '../shared/utils';
+import { wrapLogger } from '../../../common/wrap/wrap-logger';
+import { globalScope } from '../../../common/constants/runtime';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto);
     const instanceEE = this.ee;
+    wrapLogger(instanceEE, globalScope.console, 'log', {
+      level: 'info'
+    });
+    wrapLogger(instanceEE, globalScope.console, 'error', {
+      level: 'error'
+    });
+    wrapLogger(instanceEE, globalScope.console, 'warn', {
+      level: 'warn'
+    });
+    wrapLogger(instanceEE, globalScope.console, 'info', {
+      level: 'info'
+    });
+    wrapLogger(instanceEE, globalScope.console, 'debug', {
+      level: 'debug'
+    });
+    wrapLogger(instanceEE, globalScope.console, 'trace', {
+      level: 'trace'
+    });
     /** emitted by wrap-logger function */
     this.ee.on('wrap-logger-end', function handleLog([message]) {
       const {

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

@@ -24,6 +24,7 @@ import { now } from '../../../common/timing/now';
 import { buildNRMetaNode } from '../shared/utils';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 import { cleanURL } from '../../../common/url/clean-url';
+import { canEnableSessionTracking } from '../../utils/feature-gates';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   mode = MODE.OFF;
@@ -47,6 +48,7 @@ export class Aggregate extends AggregateBase {
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     this.harvestOpts.raw = true;
+    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session;
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee);
 
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
@@ -69,7 +71,7 @@ export class Aggregate extends AggregateBase {
     this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
       if (!this.recorder || !this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
       if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
-      this.mode = data.sessionReplay;
+      this.mode = data.sessionReplayMode;
     });
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode === MODE.FULL);
@@ -143,7 +145,7 @@ export class Aggregate extends AggregateBase {
 
   /**
    * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
-   * @param {boolean} entitlements - the true/false state of the "sr" flag from RUM response
+   * @param {boolean} srMode - the true/false state of the "sr" flag (aka. entitlements) from RUM response
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
@@ -391,6 +393,8 @@ export class Aggregate extends AggregateBase {
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
   }
   syncWithSessionManager(state = {}) {
-    this.agentRef.runtime.session.write(state);
+    if (this.isSessionTrackingEnabled) {
+      this.agentRef.runtime.session.write(state);
+    }
   }
 }

package/dist/esm/features/utils/aggregate-base.js

@@ -71,6 +71,9 @@ export class AggregateBase extends FeatureBase {
     drain(this.agentIdentifier, this.featureName);
     this.drained = true;
   }
+  preHarvestChecks(opts) {
+    return !this.blocked;
+  }
 
   /**
    * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.

package/dist/esm/loaders/agent.js

@@ -19,13 +19,24 @@ import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum';
 import { warn } from '../common/util/console';
 import { globalScope } from '../common/constants/runtime';
 
+/**
+ * @typedef {Object} AgentOptions
+ * @property {import('../common/config/info').Info} info - An object containing operational info needed by the agent. It's strongly encouraged to define this.
+ * @property {import('../common/config/init').Init} [init] - An object containing initialization configurations for the agent.
+ * @property {Object} [loader_config] - An object containing configuration primarily passed by APM injection. This is not recommended for use if not already provided by installation.
+ * @property {Object} [runtime] - An object containing runtime references by the agent. This is not recommended for use.
+ * @property {Array<Object>} [features] - A list of feature modules to include in the agent. This is only necessary when using the `Agent` class strictly.
+ * @property {boolean} [exposed] - Whether the agent should expose its API to (be affected by) the global `newrelic` object.
+ * @property {string} [loaderType] - The type of loader that is initializing the agent. It's recommended to allow the default.
+ */
+
 /**
  * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 export class Agent extends AgentBase {
   /**
-   * @param {Object} options Options to initialize agent with
+   * @param {AgentOptions} options
    */
   constructor(options) {
     super();

package/dist/esm/loaders/browser-agent.js

@@ -20,9 +20,12 @@ import { Instrument as InstrumentSoftNav } from '../features/soft_navigations/in
  * The BrowserAgent class is the most convenient and reliable option for most use cases.
  */
 export class BrowserAgent extends Agent {
-  constructor(args) {
+  /**
+   * @param {import('./agent').AgentOptions} options
+   */
+  constructor(options) {
     super({
-      ...args,
+      ...options,
       features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentMetrics, InstrumentErrors, InstrumentSpa, InstrumentSoftNav, InstrumentSessionReplay, InstrumentGenericEvents, InstrumentLogs],
       loaderType: 'browser-agent'
     });

package/dist/esm/loaders/micro-agent.js

@@ -21,7 +21,7 @@ const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.genericEvents, FE
  */
 export class MicroAgent extends MicroAgentBase {
   /**
-   * @param {Object} options - Specifies features and runtime configuration,
+   * @param {import('./agent').AgentOptions} options
    */
   constructor(options) {
     super();

package/dist/types/common/config/info.d.ts

@@ -1,4 +1,35 @@
 export function isValid(id: any): boolean;
 export function getInfo(id: any): any;
 export function setInfo(id: any, obj: any): void;
+export type Info = {
+    beacon?: string | undefined;
+    /**
+     * - Base URL endpoint for all data harvested by the agent. Proxies should be defined in the init instead.
+     */
+    errorBeacon?: string | undefined;
+    /**
+     * - New Relic license key provided by the website in user account.
+     */
+    licenseKey: string;
+    /**
+     * - New Relic application ID provided when creating a browser entity in the UI.
+     */
+    applicationID: string;
+    sa?: number | undefined;
+    queueTime?: number | undefined;
+    applicationTime?: number | undefined;
+    ttGuid?: string | undefined;
+    user?: string | undefined;
+    account?: string | undefined;
+    product?: string | undefined;
+    extra?: string | undefined;
+    /**
+     * - Custom attributes that are added to majority of agent's payloads. The `setCustomAttribute` API method affects this.
+     */
+    jsAttributes?: Object | undefined;
+    userAttributes?: string | undefined;
+    atts?: string | undefined;
+    transactionName?: string | undefined;
+    tNamePlain?: string | undefined;
+};
 //# sourceMappingURL=info.d.ts.map

package/dist/types/common/config/info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../../src/common/config/info.js"],"names":[],"mappings":"AAiCA,0CAOC;AAED,sCAIC;AAED,iDAKC"}
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../../src/common/config/info.js"],"names":[],"mappings":"AAoDA,0CAOC;AAED,sCAIC;AAED,iDAKC;;;;;;;;;;gBA7Da,MAAM;;;;mBACN,MAAM"}