@newrelic/browser-agent 1.305.0-rc.3 → 1.305.0-rc.5

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

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.305.0-rc.3";
+const VERSION = exports.VERSION = "1.305.0-rc.5";
 
 /**
  * Exposes the build type of the agent

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

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.305.0-rc.3";
+const VERSION = exports.VERSION = "1.305.0-rc.5";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/runtime.js

@@ -54,5 +54,5 @@ const ffVersion = exports.ffVersion = (() => {
  * @type {number}
  */
 const originTime = exports.originTime = Date.now() - (0, _now.now)();
-const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.length > 0;
+const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.[0]?.responseStart;
 exports.supportsNavTimingL2 = supportsNavTimingL2;

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

@@ -36,6 +36,7 @@ const model = {
   sessionTraceMode: _constants.MODE.OFF,
   traceHarvestStarted: false,
   loggingMode: _constants3.LOGGING_MODE.OFF,
+  logApiMode: _constants3.LOGGING_MODE.OFF,
   serverTimeDiff: null,
   // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {},

package/dist/cjs/common/vitals/time-to-first-byte.js

@@ -21,6 +21,7 @@ const timeToFirstByte = exports.timeToFirstByte = new _vitalMetric.VitalMetric(_
  * - in browsers that do not support PerformanceNavigationTiming API
  * - in an iOS browser
  * - cross-origin iframes specifically in firefox and safari
+ * - onTTFB relies on a truthy `responseStart` value, should ensure that exists before relying on it (seen to be falsy in certain Electron.js cases for instance)
  */
 if (_runtime.isBrowserScope && (0, _runtime.supportsNavTimingL2)() && !_runtime.isiOS && window === window.parent) {
   (0, _attribution.onTTFB)(({

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

@@ -26,10 +26,11 @@ const contextMap = new Map();
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @param {Object} parent - The parent object housing the logger function
  * @param {string} loggerFn - The name of the function in the parent object to wrap
+ * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
  * @returns {Object} Scoped event emitter with a debug ID of `logger`.
  */
 // eslint-disable-next-line
-function wrapLogger(sharedEE, parent, loggerFn, context) {
+function wrapLogger(sharedEE, parent, loggerFn, context, autoCaptured = true) {
   if (!(typeof parent === 'object' && !!parent && typeof loggerFn === 'string' && !!loggerFn && typeof parent[loggerFn] === 'function')) return (0, _console.warn)(29);
   const ee = scopedEE(sharedEE);
   const wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
@@ -41,6 +42,7 @@ function wrapLogger(sharedEE, parent, loggerFn, context) {
   const ctx = new _eventContext.EventContext(_contextualEe.contextId);
   ctx.level = context.level;
   ctx.customAttributes = context.customAttributes;
+  ctx.autoCaptured = autoCaptured;
   const contextLookupKey = parent[loggerFn]?.[_wrapFunction.flag] || parent[loggerFn];
   contextMap.set(contextLookupKey, ctx);
 

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

@@ -21,11 +21,19 @@ var _mfe = require("../../../common/util/mfe");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+const LOGGING_EVENT = 'Logging/Event/';
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(agentRef.init) && agentRef.runtime.session;
+    const updateLocalLoggingMode = (auto, api) => {
+      this.loggingMode = {
+        auto,
+        api
+      };
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use.
+      if (api === undefined) this.loggingMode.api = auto;
+    };
 
     /** set up agg-level behaviors specific to this feature */
     this.harvestOpts.raw = true;
@@ -37,20 +45,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
     });
     this.ee.on(_constants2.SESSION_EVENTS.UPDATE, (type, data) => {
       if (this.blocked || type !== _constants2.SESSION_EVENT_TYPES.CROSS_TAB) return;
-      if (this.loggingMode !== _constants.LOGGING_MODE.OFF && data.loggingMode === _constants.LOGGING_MODE.OFF) this.abort(_constants3.ABORT_REASONS.CROSS_TAB);else this.loggingMode = data.loggingMode;
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use with just loggingMode off == feature off.
+      if (data.loggingMode === _constants.LOGGING_MODE.OFF && (!data.logApiMode || data.logApiMode === _constants.LOGGING_MODE.OFF)) this.abort(_constants3.ABORT_REASONS.CROSS_TAB);else updateLocalLoggingMode(data.loggingMode, data.logApiMode);
     });
-    this.waitForFlags(['log']).then(([loggingMode]) => {
-      const session = this.agentRef.runtime.session ?? {};
-      if (this.loggingMode === _constants.LOGGING_MODE.OFF || session.isNew && loggingMode === _constants.LOGGING_MODE.OFF) {
+    this.waitForFlags(['log', 'logapi']).then(([auto, api]) => {
+      if (this.blocked) return; // means abort already happened before this, likely from session reset or update; abort would've set mode off + deregistered drain
+
+      this.loggingMode ??= {
+        auto,
+        api
+      }; // likewise, don't want to overwrite the mode if it was set already
+      const session = this.agentRef.runtime.session;
+      if ((0, _featureGates.canEnableSessionTracking)(agentRef.init) && session) {
+        if (session.isNew) this.#syncWithSessionManager();else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode);
+      }
+      if (this.loggingMode.auto === _constants.LOGGING_MODE.OFF && this.loggingMode.api === _constants.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 */
       (0, _registerHandler.registerHandler)(_constants.LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee);
@@ -59,14 +72,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
       agentRef.runtime.harvester.triggerHarvestFor(this);
     });
   }
-  updateLoggingMode(loggingMode) {
-    this.loggingMode = loggingMode;
-    this.syncWithSessionManager({
-      loggingMode: this.loggingMode
-    });
-  }
-  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO, target) {
-    if (this.blocked || !this.loggingMode) return;
+  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO, autoCaptured, target) {
+    if (this.blocked) return;
+    // Check respective logging mode depending on whether this log is from auto wrapped instrumentation or manual API that it's not turned off.
+    const modeForThisLog = autoCaptured ? this.loggingMode.auto : this.loggingMode.api;
+    if (!modeForThisLog) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
     attributes = {
       ...attributes,
@@ -75,8 +85,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     };
     if (typeof level === 'string') level = level.toUpperCase();
     if (!(0, _utils.isValidLogLevel)(level)) return (0, _console.warn)(30, level);
-    if (this.loggingMode < (_constants.LOGGING_MODE[level] || Infinity)) {
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Sampling');
+    if (modeForThisLog < (_constants.LOGGING_MODE[level] || Infinity)) {
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Sampling');
       return;
     }
     try {
@@ -91,12 +101,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
     } catch (err) {
       (0, _console.warn)(16, message);
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Casting');
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Casting');
       return;
     }
     if (typeof message !== 'string' || !message) return (0, _console.warn)(32);
     const log = new _log.Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
-    this.events.add(log);
+    if (this.events.add(log)) this.reportSupportabilityMetric(LOGGING_EVENT + (autoCaptured ? 'Auto' : 'API') + '/Added');
   }
   serializer(eventBuffer) {
     const sessionEntity = this.agentRef.runtime.session;
@@ -146,13 +156,18 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.events.clear();
       this.events.clearSave();
     }
-    this.updateLoggingMode(_constants.LOGGING_MODE.OFF);
+    this.loggingMode = {
+      auto: _constants.LOGGING_MODE.OFF,
+      api: _constants.LOGGING_MODE.OFF
+    };
+    this.#syncWithSessionManager();
     this.deregisterDrain();
   }
-  syncWithSessionManager(state = {}) {
-    if (this.isSessionTrackingEnabled) {
-      this.agentRef.runtime.session.write(state);
-    }
+  #syncWithSessionManager() {
+    this.agentRef.runtime.session?.write({
+      loggingMode: this.loggingMode.auto,
+      logApiMode: this.loggingMode.api
+    });
   }
 }
 exports.Aggregate = Aggregate;

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

@@ -39,9 +39,10 @@ class Instrument extends _instrumentBase.InstrumentBase {
     this.ee.on('wrap-logger-end', function handleLog([message]) {
       const {
         level,
-        customAttributes
+        customAttributes,
+        autoCaptured
       } = this;
-      (0, _utils.bufferLog)(instanceEE, message, customAttributes, level);
+      (0, _utils.bufferLog)(instanceEE, message, customAttributes, level, autoCaptured);
     });
     this.importAggregator(agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "logging-aggregate" */'../aggregate'))));
   }

package/dist/cjs/features/logging/shared/utils.js

@@ -20,11 +20,12 @@ var _constants2 = require("../constants");
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
+   * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
    * @param {object=} target - the optional target provided by an api call
    */
-function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO, target, timestamp = (0, _now.now)()) {
+function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO, autoCaptured = true, target, timestamp = (0, _now.now)()) {
   (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, _features.FEATURE_NAMES.metrics, ee);
-  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, target], undefined, _features.FEATURE_NAMES.logging, ee);
+  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, autoCaptured, target], undefined, _features.FEATURE_NAMES.logging, ee);
 }
 
 /**

package/dist/cjs/loaders/api/log.js

@@ -22,5 +22,5 @@ function log(message, {
   customAttributes = {},
   level = _constants.LOG_LEVELS.INFO
 } = {}, agentRef, target, timestamp = (0, _now.now)()) {
-  (0, _utils.bufferLog)(agentRef.ee, message, customAttributes, level, target, timestamp);
+  (0, _utils.bufferLog)(agentRef.ee, message, customAttributes, level, false, target, timestamp);
 }

package/dist/cjs/loaders/api/wrapLogger.js

@@ -21,6 +21,6 @@ function setupWrapLoggerAPI(agent) {
     (0, _wrapLogger.wrapLogger)(agent.ee, parent, functionName, {
       customAttributes,
       level
-    });
+    }, false);
   }, agent);
 }

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.305.0-rc.3";
+export const VERSION = "1.305.0-rc.5";
 
 /**
  * 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.305.0-rc.3";
+export const VERSION = "1.305.0-rc.5";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/runtime.js

@@ -49,4 +49,4 @@ export const ffVersion = (() => {
  * @type {number}
  */
 export const originTime = Date.now() - now();
-export const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.length > 0;
+export const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.[0]?.responseStart;

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

@@ -30,6 +30,7 @@ const model = {
   sessionTraceMode: MODE.OFF,
   traceHarvestStarted: false,
   loggingMode: LOGGING_MODE.OFF,
+  logApiMode: LOGGING_MODE.OFF,
   serverTimeDiff: null,
   // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {},

package/dist/esm/common/vitals/time-to-first-byte.js

@@ -14,6 +14,7 @@ export const timeToFirstByte = new VitalMetric(VITAL_NAMES.TIME_TO_FIRST_BYTE);
  * - in browsers that do not support PerformanceNavigationTiming API
  * - in an iOS browser
  * - cross-origin iframes specifically in firefox and safari
+ * - onTTFB relies on a truthy `responseStart` value, should ensure that exists before relying on it (seen to be falsy in certain Electron.js cases for instance)
  */
 if (isBrowserScope && supportsNavTimingL2() && !isiOS && window === window.parent) {
   onTTFB(({

package/dist/esm/common/wrap/wrap-logger.js

@@ -19,10 +19,11 @@ const contextMap = new Map();
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @param {Object} parent - The parent object housing the logger function
  * @param {string} loggerFn - The name of the function in the parent object to wrap
+ * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
  * @returns {Object} Scoped event emitter with a debug ID of `logger`.
  */
 // eslint-disable-next-line
-export function wrapLogger(sharedEE, parent, loggerFn, context) {
+export function wrapLogger(sharedEE, parent, loggerFn, context, autoCaptured = true) {
   if (!(typeof parent === 'object' && !!parent && typeof loggerFn === 'string' && !!loggerFn && typeof parent[loggerFn] === 'function')) return warn(29);
   const ee = scopedEE(sharedEE);
   const wrapFn = wfn(ee);
@@ -34,6 +35,7 @@ export function wrapLogger(sharedEE, parent, loggerFn, context) {
   const ctx = new EventContext(contextId);
   ctx.level = context.level;
   ctx.customAttributes = context.customAttributes;
+  ctx.autoCaptured = autoCaptured;
   const contextLookupKey = parent[loggerFn]?.[flag] || parent[loggerFn];
   contextMap.set(contextLookupKey, ctx);
 

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

@@ -14,11 +14,19 @@ import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/con
 import { ABORT_REASONS } from '../../session_replay/constants';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
 import { getVersion2Attributes } from '../../../common/util/mfe';
+const LOGGING_EVENT = 'Logging/Event/';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && agentRef.runtime.session;
+    const updateLocalLoggingMode = (auto, api) => {
+      this.loggingMode = {
+        auto,
+        api
+      };
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use.
+      if (api === undefined) this.loggingMode.api = auto;
+    };
 
     /** set up agg-level behaviors specific to this feature */
     this.harvestOpts.raw = true;
@@ -30,20 +38,25 @@ export class Aggregate extends AggregateBase {
     });
     this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
       if (this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
-      if (this.loggingMode !== LOGGING_MODE.OFF && data.loggingMode === LOGGING_MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);else this.loggingMode = data.loggingMode;
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use with just loggingMode off == feature off.
+      if (data.loggingMode === LOGGING_MODE.OFF && (!data.logApiMode || data.logApiMode === LOGGING_MODE.OFF)) this.abort(ABORT_REASONS.CROSS_TAB);else updateLocalLoggingMode(data.loggingMode, data.logApiMode);
     });
-    this.waitForFlags(['log']).then(([loggingMode]) => {
-      const session = this.agentRef.runtime.session ?? {};
-      if (this.loggingMode === LOGGING_MODE.OFF || session.isNew && loggingMode === LOGGING_MODE.OFF) {
+    this.waitForFlags(['log', 'logapi']).then(([auto, api]) => {
+      if (this.blocked) return; // means abort already happened before this, likely from session reset or update; abort would've set mode off + deregistered drain
+
+      this.loggingMode ??= {
+        auto,
+        api
+      }; // likewise, don't want to overwrite the mode if it was set already
+      const session = this.agentRef.runtime.session;
+      if (canEnableSessionTracking(agentRef.init) && session) {
+        if (session.isNew) this.#syncWithSessionManager();else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode);
+      }
+      if (this.loggingMode.auto === LOGGING_MODE.OFF && this.loggingMode.api === 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);
@@ -52,14 +65,11 @@ 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, target) {
-    if (this.blocked || !this.loggingMode) return;
+  handleLog(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, autoCaptured, target) {
+    if (this.blocked) return;
+    // Check respective logging mode depending on whether this log is from auto wrapped instrumentation or manual API that it's not turned off.
+    const modeForThisLog = autoCaptured ? this.loggingMode.auto : this.loggingMode.api;
+    if (!modeForThisLog) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
     attributes = {
       ...attributes,
@@ -68,8 +78,8 @@ export class Aggregate extends AggregateBase {
     };
     if (typeof level === 'string') level = level.toUpperCase();
     if (!isValidLogLevel(level)) return warn(30, level);
-    if (this.loggingMode < (LOGGING_MODE[level] || Infinity)) {
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Sampling');
+    if (modeForThisLog < (LOGGING_MODE[level] || Infinity)) {
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Sampling');
       return;
     }
     try {
@@ -84,12 +94,12 @@ export class Aggregate extends AggregateBase {
       }
     } catch (err) {
       warn(16, message);
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Casting');
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Casting');
       return;
     }
     if (typeof message !== 'string' || !message) return warn(32);
     const log = new Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
-    this.events.add(log);
+    if (this.events.add(log)) this.reportSupportabilityMetric(LOGGING_EVENT + (autoCaptured ? 'Auto' : 'API') + '/Added');
   }
   serializer(eventBuffer) {
     const sessionEntity = this.agentRef.runtime.session;
@@ -139,12 +149,17 @@ export class Aggregate extends AggregateBase {
       this.events.clear();
       this.events.clearSave();
     }
-    this.updateLoggingMode(LOGGING_MODE.OFF);
+    this.loggingMode = {
+      auto: LOGGING_MODE.OFF,
+      api: LOGGING_MODE.OFF
+    };
+    this.#syncWithSessionManager();
     this.deregisterDrain();
   }
-  syncWithSessionManager(state = {}) {
-    if (this.isSessionTrackingEnabled) {
-      this.agentRef.runtime.session.write(state);
-    }
+  #syncWithSessionManager() {
+    this.agentRef.runtime.session?.write({
+      loggingMode: this.loggingMode.auto,
+      logApiMode: this.loggingMode.api
+    });
   }
 }

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

@@ -33,9 +33,10 @@ export class Instrument extends InstrumentBase {
     this.ee.on('wrap-logger-end', function handleLog([message]) {
       const {
         level,
-        customAttributes
+        customAttributes,
+        autoCaptured
       } = this;
-      bufferLog(instanceEE, message, customAttributes, level);
+      bufferLog(instanceEE, message, customAttributes, level, autoCaptured);
     });
     this.importAggregator(agentRef, () => import(/* webpackChunkName: "logging-aggregate" */'../aggregate'));
   }

package/dist/esm/features/logging/shared/utils.js

@@ -13,11 +13,12 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
+   * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
    * @param {object=} target - the optional target provided by an api call
    */
-export function bufferLog(ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, target, timestamp = now()) {
+export function bufferLog(ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, autoCaptured = true, target, timestamp = now()) {
   handle(SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, FEATURE_NAMES.metrics, ee);
-  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, target], undefined, FEATURE_NAMES.logging, ee);
+  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, autoCaptured, target], undefined, FEATURE_NAMES.logging, ee);
 }
 
 /**

package/dist/esm/loaders/api/log.js

@@ -15,5 +15,5 @@ export function log(message, {
   customAttributes = {},
   level = LOG_LEVELS.INFO
 } = {}, agentRef, target, timestamp = now()) {
-  bufferLog(agentRef.ee, message, customAttributes, level, target, timestamp);
+  bufferLog(agentRef.ee, message, customAttributes, level, false, target, timestamp);
 }

package/dist/esm/loaders/api/wrapLogger.js

@@ -14,6 +14,6 @@ export function setupWrapLoggerAPI(agent) {
     wrapLogger(agent.ee, parent, functionName, {
       customAttributes,
       level
-    });
+    }, false);
   }, agent);
 }

package/dist/types/common/constants/runtime.d.ts

@@ -26,5 +26,5 @@ export const ffVersion: number;
  * @type {number}
  */
 export const originTime: number;
-export function supportsNavTimingL2(): boolean;
+export function supportsNavTimingL2(): any;
 //# sourceMappingURL=runtime.d.ts.map

package/dist/types/common/constants/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ;;;;GAIG;AACH,yBAFU,MAAM,CAE4B;AAErC,+CAA4J"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ;;;;GAIG;AACH,yBAFU,MAAM,CAE4B;AAErC,2CAAoK"}

package/dist/types/common/session/session-entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AAsCA;IACE;;;;;OAKG;IACH,uBA+BC;IAzBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAoBnC;;;;;aAgFC;IApEC,8BAA0B;IAC1B,+BAA4B;IAe1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAKzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBA4BC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA3TqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AAuCA;IACE;;;;;OAKG;IACH,uBA+BC;IAzBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAoBnC;;;;;aAgFC;IApEC,8BAA0B;IAC1B,+BAA4B;IAe1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAKzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBA4BC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBA5TqB,gBAAgB;iCAGL,4BAA4B"}

package/dist/types/common/wrap/wrap-logger.d.ts

@@ -3,9 +3,10 @@
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @param {Object} parent - The parent object housing the logger function
  * @param {string} loggerFn - The name of the function in the parent object to wrap
+ * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
  * @returns {Object} Scoped event emitter with a debug ID of `logger`.
  */
-export function wrapLogger(sharedEE: Object, parent: Object, loggerFn: string, context: any): Object;
+export function wrapLogger(sharedEE: Object, parent: Object, loggerFn: string, context: any, autoCaptured?: boolean): Object;
 /**
  * Returns an event emitter scoped specifically for the `logger` context. This scoping is a remnant from when all the
  * features shared the same group in the event, to isolate events between features. It will likely be revisited.

package/dist/types/common/wrap/wrap-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-logger.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-logger.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AAEH,qCANW,MAAM,UACN,MAAM,YACN,MAAM,iBACJ,MAAM,CAuBlB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}
+{"version":3,"file":"wrap-logger.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-logger.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AAEH,qCAPW,MAAM,UACN,MAAM,YACN,MAAM,+BACN,OAAO,GACL,MAAM,CAwBlB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}

package/dist/types/features/logging/aggregate/index.d.ts

@@ -1,10 +1,11 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
     constructor(agentRef: any);
-    isSessionTrackingEnabled: any;
-    loggingMode: any;
-    updateLoggingMode(loggingMode: any): void;
-    handleLog(timestamp: any, message: any, attributes: {} | undefined, level: string | undefined, target: any): void;
+    loggingMode: {
+        auto: any;
+        api: any;
+    };
+    handleLog(timestamp: any, message: any, attributes: {} | undefined, level: string | undefined, autoCaptured: any, target: any): void;
     serializer(eventBuffer: any): {
         common: {
             /** Attributes in the `common` section are added to `all` logs generated in the payload */
@@ -18,7 +19,7 @@ export class Aggregate extends AggregateBase {
     };
     /** Abort the feature, once aborted it will not resume */
     abort(reason?: {}): void;
-    syncWithSessionManager(state?: {}): void;
+    #private;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/features/logging/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,2BAsCC;IApCC,8BAAmG;IAc5F,iBAAmC;IAwB5C,0CAKC;IAED,kHA4CC;IAED;;YAIM,0FAA0F;;;QAqB5F,0DAA0D;;QAM7D;IAED;;MAEC;IAED,yDAAyD;IACzD,yBASC;IAED,yCAIC;CACF;8BA/J6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/aggregate/index.js"],"names":[],"mappings":"AAmBA;IACE,2BAAiC;IACjC,2BA4CC;IAzCG;;;MAAgC;IA2CpC,qIA+CC;IAED;;YAIM,0FAA0F;;;QAqB5F,0DAA0D;;QAM7D;IAED;;MAEC;IAED,yDAAyD;IACzD,yBAaC;;CAQF;8BAxK6B,4BAA4B"}

package/dist/types/features/logging/shared/utils.d.ts

@@ -3,11 +3,12 @@
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
+   * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
    * @param {object=} target - the optional target provided by an api call
    */
 export function bufferLog(ee: ContextualEE, message: string, customAttributes?: {
     [key: string]: any;
-}, level?: enum, target?: object | undefined, timestamp?: number): void;
+}, level?: enum, autoCaptured?: boolean, target?: object | undefined, timestamp?: number): void;
 /**
  * Checks if a supplied log level is acceptable for use in generating a log event
  * @param {string} level -- must be cast to uppercase before running this test

package/dist/types/features/logging/shared/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/shared/utils.js"],"names":[],"mappings":"AAUA;;;;;;KAMK;AACL,8BANa,YAAY,WACZ,MAAM,qBACN;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAC,CAAA;CAAC,UAClB,IAAI,WACJ,MAAM,YAAC,4BAKnB;AAED;;;;GAIG;AACH,uCAHW,MAAM,GACJ,OAAO,CAKnB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/shared/utils.js"],"names":[],"mappings":"AAUA;;;;;;;KAOK;AACL,8BAPa,YAAY,WACZ,MAAM,qBACN;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAC,CAAA;CAAC,UAClB,IAAI,iBACJ,OAAO,WACP,MAAM,YAAC,4BAKnB;AAED;;;;GAIG;AACH,uCAHW,MAAM,GACJ,OAAO,CAKnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.305.0-rc.3",
+  "version": "1.305.0-rc.5",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -195,6 +195,7 @@
     "build:npm": "npm run npm:build:esm && npm run npm:build:cjs && npm run npm:build:types && npm run npm:pack",
     "cdn:build": "npm run cdn:build:prod",
     "cdn:build:local": "npm run cdn:webpack",
+    "cdn:build:local-external": "npm run cdn:webpack -- --env mode=local-external",
     "cdn:build:prod": "npm run cdn:webpack -- --env mode=prod",
     "cdn:build:dev": "npm run cdn:webpack -- --env mode=dev",
     "cdn:build:experiment": "npm run cdn:webpack -- --env mode=experiment",

package/src/common/constants/runtime.js

@@ -84,4 +84,4 @@ export const ffVersion = (() => {
  */
 export const originTime = Date.now() - now()
 
-export const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.length > 0
+export const supportsNavTimingL2 = () => typeof PerformanceNavigationTiming !== 'undefined' && globalScope?.performance?.getEntriesByType('navigation')?.[0]?.responseStart

package/src/common/session/session-entity.js

@@ -30,6 +30,7 @@ const model = {
   sessionTraceMode: MODE.OFF,
   traceHarvestStarted: false,
   loggingMode: LOGGING_MODE.OFF,
+  logApiMode: LOGGING_MODE.OFF,
   serverTimeDiff: null, // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {},
   numOfResets: 0,

package/src/common/vitals/time-to-first-byte.js

@@ -15,6 +15,7 @@ export const timeToFirstByte = new VitalMetric(VITAL_NAMES.TIME_TO_FIRST_BYTE)
  * - in browsers that do not support PerformanceNavigationTiming API
  * - in an iOS browser
  * - cross-origin iframes specifically in firefox and safari
+ * - onTTFB relies on a truthy `responseStart` value, should ensure that exists before relying on it (seen to be falsy in certain Electron.js cases for instance)
  */
 if (isBrowserScope && supportsNavTimingL2() && !isiOS && window === window.parent) {
   onTTFB(({ value, attribution }) => {

package/src/common/wrap/wrap-logger.js

@@ -20,10 +20,11 @@ const contextMap = new Map()
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @param {Object} parent - The parent object housing the logger function
  * @param {string} loggerFn - The name of the function in the parent object to wrap
+ * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
  * @returns {Object} Scoped event emitter with a debug ID of `logger`.
  */
 // eslint-disable-next-line
-export function wrapLogger(sharedEE, parent, loggerFn, context) {
+export function wrapLogger(sharedEE, parent, loggerFn, context, autoCaptured = true) {
   if (!(typeof parent === 'object' && !!parent && typeof loggerFn === 'string' && !!loggerFn && typeof parent[loggerFn] === 'function')) return warn(29)
   const ee = scopedEE(sharedEE)
   const wrapFn = wfn(ee)
@@ -35,6 +36,7 @@ export function wrapLogger(sharedEE, parent, loggerFn, context) {
   const ctx = new EventContext(contextId)
   ctx.level = context.level
   ctx.customAttributes = context.customAttributes
+  ctx.autoCaptured = autoCaptured
 
   const contextLookupKey = parent[loggerFn]?.[flag] || parent[loggerFn]
   contextMap.set(contextLookupKey, ctx)

package/src/features/logging/aggregate/index.js

@@ -15,11 +15,17 @@ import { ABORT_REASONS } from '../../session_replay/constants'
 import { canEnableSessionTracking } from '../../utils/feature-gates'
 import { getVersion2Attributes } from '../../../common/util/mfe'
 
+const LOGGING_EVENT = 'Logging/Event/'
+
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-    this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && agentRef.runtime.session
+    const updateLocalLoggingMode = (auto, api) => {
+      this.loggingMode = { auto, api }
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use.
+      if (api === undefined) this.loggingMode.api = auto
+    }
 
     /** set up agg-level behaviors specific to this feature */
     this.harvestOpts.raw = true
@@ -29,25 +35,27 @@ export class Aggregate extends AggregateBase {
     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.loggingMode !== LOGGING_MODE.OFF && data.loggingMode === LOGGING_MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB)
-      else this.loggingMode = data.loggingMode
+      // In agent v1.290.0 & under, the logApiMode prop did not yet exist, so need to account for old session state being in-use with just loggingMode off == feature off.
+      if (data.loggingMode === LOGGING_MODE.OFF && (!data.logApiMode || data.logApiMode === LOGGING_MODE.OFF)) this.abort(ABORT_REASONS.CROSS_TAB)
+      else updateLocalLoggingMode(data.loggingMode, data.logApiMode)
     })
 
-    this.waitForFlags(['log']).then(([loggingMode]) => {
-      const session = this.agentRef.runtime.session ?? {}
-      if (this.loggingMode === LOGGING_MODE.OFF || (session.isNew && loggingMode === LOGGING_MODE.OFF)) {
+    this.waitForFlags(['log', 'logapi']).then(([auto, api]) => {
+      if (this.blocked) return // means abort already happened before this, likely from session reset or update; abort would've set mode off + deregistered drain
+
+      this.loggingMode ??= { auto, api } // likewise, don't want to overwrite the mode if it was set already
+      const session = this.agentRef.runtime.session
+      if (canEnableSessionTracking(agentRef.init) && session) {
+        if (session.isNew) this.#syncWithSessionManager()
+        else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode)
+      }
+      if (this.loggingMode.auto === LOGGING_MODE.OFF && this.loggingMode.api === 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)
@@ -57,15 +65,11 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  updateLoggingMode (loggingMode) {
-    this.loggingMode = loggingMode
-    this.syncWithSessionManager({
-      loggingMode: this.loggingMode
-    })
-  }
-
-  handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, target) {
-    if (this.blocked || !this.loggingMode) return
+  handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, autoCaptured, target) {
+    if (this.blocked) return
+    // Check respective logging mode depending on whether this log is from auto wrapped instrumentation or manual API that it's not turned off.
+    const modeForThisLog = autoCaptured ? this.loggingMode.auto : this.loggingMode.api
+    if (!modeForThisLog) return
 
     if (!attributes || typeof attributes !== 'object') attributes = {}
 
@@ -77,8 +81,8 @@ export class Aggregate extends AggregateBase {
 
     if (typeof level === 'string') level = level.toUpperCase()
     if (!isValidLogLevel(level)) return warn(30, level)
-    if (this.loggingMode < (LOGGING_MODE[level] || Infinity)) {
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Sampling')
+    if (modeForThisLog < (LOGGING_MODE[level] || Infinity)) {
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Sampling')
       return
     }
 
@@ -95,7 +99,7 @@ export class Aggregate extends AggregateBase {
       }
     } catch (err) {
       warn(16, message)
-      this.reportSupportabilityMetric('Logging/Event/Dropped/Casting')
+      this.reportSupportabilityMetric(LOGGING_EVENT + 'Dropped/Casting')
       return
     }
     if (typeof message !== 'string' || !message) return warn(32)
@@ -107,7 +111,7 @@ export class Aggregate extends AggregateBase {
       level
     )
 
-    this.events.add(log)
+    if (this.events.add(log)) this.reportSupportabilityMetric(LOGGING_EVENT + (autoCaptured ? 'Auto' : 'API') + '/Added')
   }
 
   serializer (eventBuffer) {
@@ -155,13 +159,18 @@ export class Aggregate extends AggregateBase {
       this.events.clear()
       this.events.clearSave()
     }
-    this.updateLoggingMode(LOGGING_MODE.OFF)
+    this.loggingMode = {
+      auto: LOGGING_MODE.OFF,
+      api: LOGGING_MODE.OFF
+    }
+    this.#syncWithSessionManager()
     this.deregisterDrain()
   }
 
-  syncWithSessionManager (state = {}) {
-    if (this.isSessionTrackingEnabled) {
-      this.agentRef.runtime.session.write(state)
-    }
+  #syncWithSessionManager () {
+    this.agentRef.runtime.session?.write({
+      loggingMode: this.loggingMode.auto,
+      logApiMode: this.loggingMode.api
+    })
   }
 }

package/src/features/logging/instrument/index.js

@@ -32,8 +32,8 @@ export class Instrument extends InstrumentBase {
 
     /** emitted by wrap-logger function */
     this.ee.on('wrap-logger-end', function handleLog ([message]) {
-      const { level, customAttributes } = this
-      bufferLog(instanceEE, message, customAttributes, level)
+      const { level, customAttributes, autoCaptured } = this
+      bufferLog(instanceEE, message, customAttributes, level, autoCaptured)
     })
     this.importAggregator(agentRef, () => import(/* webpackChunkName: "logging-aggregate" */ '../aggregate'))
   }

package/src/features/logging/shared/utils.js

@@ -13,11 +13,12 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants'
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
+   * @param {boolean} [autoCaptured=true] - True if log was captured from auto wrapping. False if it was captured from the API manual usage.
    * @param {object=} target - the optional target provided by an api call
    */
-export function bufferLog (ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, target, timestamp = now()) {
+export function bufferLog (ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, autoCaptured = true, target, timestamp = now()) {
   handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/logging/${level.toLowerCase()}/called`], undefined, FEATURE_NAMES.metrics, ee)
-  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, target], undefined, FEATURE_NAMES.logging, ee)
+  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, autoCaptured, target], undefined, FEATURE_NAMES.logging, ee)
 }
 
 /**

package/src/loaders/api/log.js

@@ -14,5 +14,5 @@ export function setupLogAPI (agent) {
 }
 
 export function log (message, { customAttributes = {}, level = LOG_LEVELS.INFO } = {}, agentRef, target, timestamp = now()) {
-  bufferLog(agentRef.ee, message, customAttributes, level, target, timestamp)
+  bufferLog(agentRef.ee, message, customAttributes, level, false, target, timestamp)
 }

package/src/loaders/api/wrapLogger.js

@@ -9,6 +9,6 @@ import { setupAPI } from './sharedHandlers'
 
 export function setupWrapLoggerAPI (agent) {
   setupAPI(WRAP_LOGGER, (parent, functionName, { customAttributes = {}, level = LOG_LEVELS.INFO } = {}) => {
-    wrapLogger(agent.ee, parent, functionName, { customAttributes, level })
+    wrapLogger(agent.ee, parent, functionName, { customAttributes, level }, false)
   }, agent)
 }