@newrelic/browser-agent 1.246.1 → 1.247.0

package/dist/cjs/loaders/agent.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Agent = void 0;
 require("./configure/public-path.npm");
+require("./configure/nonce.npm");
 var _agentBase = require("./agent-base");
 var _enabledFeatures = require("./features/enabled-features");
 var _configure = require("./configure/configure");
@@ -49,12 +50,15 @@ class Agent extends _agentBase.AgentBase {
       agentIdentifier: this.agentIdentifier
     });
     this.features = {};
+    (0, _nreum.setNREUMInitializedAgent)(agentIdentifier, this); // append this agent onto the global NREUM.initializedAgents
+
     this.desiredFeatures = new Set(options.features || []); // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
     // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
     // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
     // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made
     this.desiredFeatures.add(_instrument.Instrument);
-    Object.assign(this, (0, _configure.configure)(this.agentIdentifier, options, options.loaderType || 'agent'));
+    (0, _configure.configure)(this, options, options.loaderType || 'agent'); // add api, exposed, and other config properties
+
     this.run();
   }
   get config() {
@@ -66,7 +70,6 @@ class Agent extends _agentBase.AgentBase {
     };
   }
   run() {
-    const NR_FEATURES_REF_NAME = 'features';
     // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
     try {
       const enabledFeatures = (0, _enabledFeatures.getEnabledFeatures)(this.agentIdentifier);
@@ -81,7 +84,6 @@ class Agent extends _agentBase.AgentBase {
           this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator);
         }
       });
-      (0, _nreum.gosNREUMInitializedAgents)(this.agentIdentifier, this.features, NR_FEATURES_REF_NAME);
     } catch (err) {
       (0, _console.warn)('Failed to initialize all enabled instrument classes (agent aborted) -', err);
       for (const featName in this.features) {
@@ -90,7 +92,7 @@ class Agent extends _agentBase.AgentBase {
       }
       const newrelic = (0, _nreum.gosNREUM)();
       delete newrelic.initializedAgents[this.agentIdentifier]?.api; // prevent further calls to agent-specific APIs (see "configure.js")
-      delete newrelic.initializedAgents[this.agentIdentifier]?.[NR_FEATURES_REF_NAME]; // GC mem used internally by features
+      delete newrelic.initializedAgents[this.agentIdentifier]?.features; // GC mem used internally by features
       delete this.sharedAggregator;
       // Keep the initialized agent object with its configs for troubleshooting purposes.
       newrelic.ee?.abort(); // set flag and clear global backlog

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

@@ -26,7 +26,7 @@ const CUSTOM_ATTR_GROUP = 'CUSTOM/'; // the subgroup items should be stored unde
 exports.CUSTOM_ATTR_GROUP = CUSTOM_ATTR_GROUP;
 function setTopLevelCallers() {
   const nr = (0, _nreum.gosCDN)();
-  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start'];
+  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay'];
   funcs.forEach(f => {
     nr[f] = function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -147,6 +147,14 @@ function setAPI(agentIdentifier, forceDrain) {
       (0, _console.warn)('An unexpected issue occurred', err);
     }
   };
+  apiInterface.recordReplay = function () {
+    (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/recordReplay/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+    (0, _handle.handle)('recordReplay', [], undefined, _features.FEATURE_NAMES.sessionReplay, instanceEE);
+  };
+  apiInterface.pauseReplay = function () {
+    (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/pauseReplay/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+    (0, _handle.handle)('pauseReplay', [], undefined, _features.FEATURE_NAMES.sessionReplay, instanceEE);
+  };
   apiInterface.interaction = function () {
     return new InteractionHandle().get();
   };
@@ -156,6 +164,7 @@ function setAPI(agentIdentifier, forceDrain) {
       var contextStore = {};
       var ixn = this;
       var hasCb = typeof cb === 'function';
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/createTracer/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
       (0, _handle.handle)(spaPrefix + 'tracer', [(0, _now.now)(), name, contextStore], ixn, _features.FEATURE_NAMES.spa, instanceEE);
       return function () {
         tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [(0, _now.now)(), ixn, hasCb], contextStore);

package/dist/cjs/loaders/configure/configure.js

@@ -12,7 +12,10 @@ var _runtime = require("../../common/constants/runtime");
 var _publicPath = require("./public-path");
 let alreadySetOnce = false; // the configure() function can run multiple times in agent lifecycle
 
-function configure(agentIdentifier) {
+/**
+ * Sets or re-sets the agent's configuration values from global settings. This also attach those as properties to the agent instance.
+ */
+function configure(agent) {
   let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   let loaderType = arguments.length > 2 ? arguments[2] : undefined;
   let forceDrain = arguments.length > 3 ? arguments[3] : undefined;
@@ -33,31 +36,29 @@ function configure(agentIdentifier) {
     // eslint-disable-next-line camelcase
     loader_config = nr.loader_config;
   }
-  (0, _config.setConfiguration)(agentIdentifier, init || {});
+  (0, _config.setConfiguration)(agent.agentIdentifier, init || {});
   // eslint-disable-next-line camelcase
-  (0, _config.setLoaderConfig)(agentIdentifier, loader_config || {});
+  (0, _config.setLoaderConfig)(agent.agentIdentifier, loader_config || {});
   info.jsAttributes ??= {};
   if (_runtime.isWorkerScope) {
     // add a default attr to all worker payloads
     info.jsAttributes.isWorker = true;
   }
-  (0, _config.setInfo)(agentIdentifier, info);
-  const updatedInit = (0, _config.getConfiguration)(agentIdentifier);
+  (0, _config.setInfo)(agent.agentIdentifier, info);
+  const updatedInit = (0, _config.getConfiguration)(agent.agentIdentifier);
   const internalTrafficList = [info.beacon, info.errorBeacon];
   if (!alreadySetOnce) {
-    alreadySetOnce = true;
     if (updatedInit.proxy.assets) {
       (0, _publicPath.redefinePublicPath)(updatedInit.proxy.assets);
       internalTrafficList.push(updatedInit.proxy.assets);
     }
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon);
+    (0, _api.setTopLevelCallers)(); // no need to set global APIs on newrelic obj more than once
+    (0, _nreum.addToNREUM)('activatedFeatures', _featureFlags.activatedFeatures);
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
-  (0, _config.setRuntime)(agentIdentifier, runtime);
-  (0, _api.setTopLevelCallers)();
-  const api = (0, _api.setAPI)(agentIdentifier, forceDrain);
-  (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, api, 'api');
-  (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, exposed, 'exposed');
-  (0, _nreum.addToNREUM)('activatedFeatures', _featureFlags.activatedFeatures);
-  return api;
+  (0, _config.setRuntime)(agent.agentIdentifier, runtime);
+  if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain);
+  if (agent.exposed === undefined) agent.exposed = exposed;
+  alreadySetOnce = true;
 }

package/dist/cjs/loaders/configure/nonce.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/* global __webpack_require__ */
+
+__webpack_require__.nc = (() => {
+  try {
+    return document?.currentScript?.nonce;
+  } catch (ex) {
+    // Swallow error and proceed like nonce is not defined
+    // This will happen when the agent is loaded in a worker scope
+  }
+  return '';
+})();

package/dist/cjs/loaders/configure/nonce.npm.js

@@ -0,0 +1,2 @@
+// We don't support setting automating the nonce attribute in the npm package
+"use strict";

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

@@ -38,12 +38,14 @@ class MicroAgent extends _agentBase.AgentBase {
       agentIdentifier: this.agentIdentifier
     });
     this.features = {};
-    Object.assign(this, (0, _configure.configure)(this.agentIdentifier, {
+    (0, _nreum.setNREUMInitializedAgent)(agentIdentifier, this);
+    (0, _configure.configure)(this, {
       ...options,
       runtime: {
         isolatedBacklog: true
       }
-    }, options.loaderType || 'micro-agent'));
+    }, options.loaderType || 'micro-agent');
+    Object.assign(this, this.api); // the APIs should be available at the class level for micro-agent
 
     /**
      * Starts a set of agent features if not running in "autoStart" mode
@@ -98,8 +100,7 @@ class MicroAgent extends _agentBase.AgentBase {
           }
         });
       });
-      (0, _nreum.gosNREUMInitializedAgents)(this.agentIdentifier, this.features, 'features');
-      return this;
+      return true;
     } catch (err) {
       (0, _console.warn)('Failed to initialize instrument classes.', err);
       return false;

package/dist/esm/common/config/state/info.js

@@ -1,4 +1,4 @@
-import { defaults as nrDefaults, gosNREUMInitializedAgents } from '../../window/nreum';
+import { defaults as nrDefaults, getNREUMInitializedAgent } from '../../window/nreum';
 import { getModeledObject } from './configurable';
 const model = {
   // preset defaults
@@ -38,5 +38,6 @@ export function getInfo(id) {
 export function setInfo(id, obj) {
   if (!id) throw new Error('All info objects require an agent identifier!');
   _cache[id] = getModeledObject(obj, model);
-  gosNREUMInitializedAgents(id, _cache[id], 'info');
+  const agentInst = getNREUMInitializedAgent(id);
+  if (agentInst) agentInst.info = _cache[id];
 }

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

@@ -1,7 +1,7 @@
 import { isValidSelector } from '../../dom/query-selector';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../../session/constants';
 import { warn } from '../../util/console';
-import { gosNREUMInitializedAgents } from '../../window/nreum';
+import { getNREUMInitializedAgent } from '../../window/nreum';
 import { getModeledObject } from './configurable';
 const model = () => {
   const hiddenState = {
@@ -165,7 +165,8 @@ export function getConfiguration(id) {
 export function setConfiguration(id, obj) {
   if (!id) throw new Error(missingAgentIdError);
   _cache[id] = getModeledObject(obj, model());
-  gosNREUMInitializedAgents(id, _cache[id], 'config');
+  const agentInst = getNREUMInitializedAgent(id);
+  if (agentInst) agentInst.init = _cache[id];
 }
 export function getConfigurationValue(id, path) {
   if (!id) throw new Error(missingAgentIdError);

package/dist/esm/common/config/state/loader-config.js

@@ -1,4 +1,4 @@
-import { gosNREUMInitializedAgents } from '../../window/nreum';
+import { getNREUMInitializedAgent } from '../../window/nreum';
 import { getModeledObject } from './configurable';
 const model = {
   accountID: undefined,
@@ -17,5 +17,6 @@ export function getLoaderConfig(id) {
 export function setLoaderConfig(id, obj) {
   if (!id) throw new Error('All loader-config objects require an agent identifier!');
   _cache[id] = getModeledObject(obj, model);
-  gosNREUMInitializedAgents(id, _cache[id], 'loader_config');
+  const agentInst = getNREUMInitializedAgent(id);
+  if (agentInst) agentInst.loader_config = _cache[id];
 }

package/dist/esm/common/config/state/runtime.js

@@ -1,5 +1,5 @@
 import { getModeledObject } from './configurable';
-import { gosNREUMInitializedAgents } from '../../window/nreum';
+import { getNREUMInitializedAgent } from '../../window/nreum';
 import { globalScope } from '../../constants/runtime';
 import { BUILD_ENV, DIST_METHOD, VERSION } from "../../constants/env.npm";
 const model = {
@@ -31,5 +31,6 @@ export function getRuntime(id) {
 export function setRuntime(id, obj) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
   _cache[id] = getModeledObject(obj, model);
-  gosNREUMInitializedAgents(id, _cache[id], 'runtime');
+  const agentInst = getNREUMInitializedAgent(id);
+  if (agentInst) agentInst.runtime = _cache[id];
 }

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.246.1";
+export const VERSION = "1.247.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.246.1";
+export const VERSION = "1.247.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -15,6 +15,7 @@ export const isBrowserScope = typeof window !== 'undefined' && !!window.document
  */
 export const isWorkerScope = typeof WorkerGlobalScope !== 'undefined' && (typeof self !== 'undefined' && self instanceof WorkerGlobalScope && self.navigator instanceof WorkerNavigator || typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope && globalThis.navigator instanceof WorkerNavigator);
 export const globalScope = isBrowserScope ? window : typeof WorkerGlobalScope !== 'undefined' && (typeof self !== 'undefined' && self instanceof WorkerGlobalScope && self || typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope && globalThis);
+export const loadedAsDeferredBrowserScript = globalScope?.document?.readyState === 'complete';
 export const initiallyHidden = Boolean(globalScope?.document?.visibilityState === 'hidden');
 export const initialLocation = '' + globalScope?.location;
 export const isiOS = /iPad|iPhone|iPod/.test(globalScope.navigator?.userAgent);

package/dist/esm/common/dispatch/global-event.js

@@ -0,0 +1,13 @@
+import { globalScope } from '../constants/runtime';
+const GLOBAL_EVENT_NAMESPACE = 'newrelic';
+export function dispatchGlobalEvent() {
+  let detail = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  try {
+    globalScope.dispatchEvent(new CustomEvent(GLOBAL_EVENT_NAMESPACE, {
+      detail
+    }));
+  } catch (err) {
+    // something happened... dispatchEvent or CustomEvent might not be supported
+    // decide what to do about it here
+  }
+}

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

@@ -104,8 +104,8 @@ export class SessionEntity {
       this.expiresTimer = new Timer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
-          this.collectSM('expired', this);
-          this.collectSM('duration', this);
+          this.collectSM('expired');
+          this.collectSM('duration');
           this.reset();
         }
       }, this.state.expiresAt - Date.now());
@@ -121,8 +121,8 @@ export class SessionEntity {
       this.inactiveTimer = new InteractionTimer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
-          this.collectSM('inactive', this);
-          this.collectSM('duration', this);
+          this.collectSM('inactive');
+          this.collectSM('duration');
           this.reset();
         },
         // When the inactive timer refreshes, it will update the storage values with an update timestamp
@@ -172,14 +172,14 @@ export class SessionEntity {
       if (this.isInvalid(obj)) return {};
       // if the session expires, collect a SM count before resetting
       if (this.isExpired(obj.expiresAt)) {
-        this.collectSM('expired', this);
+        this.collectSM('expired');
         this.collectSM('duration', obj, true);
         return this.reset();
       }
       // if "inactive" timer is expired at "read" time -- esp. initial read -- reset
       // collect a SM count before resetting
       if (this.isExpired(obj.inactiveAt)) {
-        this.collectSM('inactive', this);
+        this.collectSM('inactive');
         this.collectSM('duration', obj, true);
         return this.reset();
       }
@@ -270,15 +270,20 @@ export class SessionEntity {
   collectSM(type, data, useUpdatedAt) {
     let value, tag;
     if (type === 'duration') {
-      const startingTimestamp = data.expiresAt - data.expiresMs;
-      const endingTimestamp = useUpdatedAt ? data.updatedAt : Date.now();
-      value = endingTimestamp - startingTimestamp;
+      value = this.getDuration(data, useUpdatedAt);
       tag = 'Session/Duration/Ms';
     }
     if (type === 'expired') tag = 'Session/Expired/Seen';
     if (type === 'inactive') tag = 'Session/Inactive/Seen';
     if (tag) handle(SUPPORTABILITY_METRIC_CHANNEL, [tag, value], undefined, FEATURE_NAMES.metrics, this.ee);
   }
+  getDuration() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state;
+    let useUpdatedAt = arguments.length > 1 ? arguments[1] : undefined;
+    const startingTimestamp = data.expiresAt - this.expiresMs;
+    const endingTimestamp = !useUpdatedAt ? data.updatedAt : Date.now();
+    return endingTimestamp - startingTimestamp;
+  }
 
   /**
    * @param {number} futureMs - The number of ms to use to generate a future timestamp

package/dist/esm/common/util/feature-flags.js

@@ -5,6 +5,7 @@
 import { ee } from '../event-emitter/contextual-ee';
 import { handle } from '../event-emitter/handle';
 import { FEATURE_NAMES } from '../../loaders/features/features';
+import { dispatchGlobalEvent } from '../dispatch/global-event';
 const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
@@ -18,18 +19,17 @@ const sentIds = new Set();
 export function activateFeatures(flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier);
   if (!(flags && typeof flags === 'object')) return;
-  if (!sentIds.has(agentIdentifier)) {
-    Object.entries(flags).forEach(_ref => {
-      let [flag, num] = _ref;
-      if (bucketMap[flag]) {
-        bucketMap[flag].forEach(feat => {
-          if (!num) handle('block-' + flag, [], undefined, feat, sharedEE);else handle('feat-' + flag, [], undefined, feat, sharedEE);
-          handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE); // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
-        });
-      } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE); // not sure what other flags are overlooked, but there's a test for ones not in the map --
-      activatedFeatures[flag] = Boolean(num);
-    });
-  }
+  if (sentIds.has(agentIdentifier)) return;
+  Object.entries(flags).forEach(_ref => {
+    let [flag, num] = _ref;
+    if (bucketMap[flag]) {
+      bucketMap[flag].forEach(feat => {
+        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE);else handle('feat-' + flag, [], undefined, feat, sharedEE);
+        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE); // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
+      });
+    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE); // not sure what other flags are overlooked, but there's a test for ones not in the map --
+    activatedFeatures[flag] = Boolean(num);
+  });
 
   // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
   // Hence, those features will not be hanging forever if their flags aren't included in the response.
@@ -40,5 +40,10 @@ export function activateFeatures(flags, agentIdentifier) {
     }
   });
   sentIds.add(agentIdentifier);
+
+  // let any window level subscribers know that the agent is running
+  dispatchGlobalEvent({
+    loaded: true
+  });
 }
 export const activatedFeatures = {};

package/dist/esm/common/window/load.js

@@ -1,5 +1,5 @@
 import { windowAddEventListener, documentAddEventListener } from '../event-listener/event-listener-opts';
-function checkState() {
+export function checkState() {
   return typeof document === 'undefined' || document.readyState === 'complete';
 }
 export function onWindowLoad(cb, useCapture) {

package/dist/esm/common/window/nreum.js

@@ -55,24 +55,24 @@ export function gosNREUMOriginals() {
   }
   return nr;
 }
-export function gosNREUMInitializedAgents(id, obj, target) {
+export function setNREUMInitializedAgent(id, newAgentInstance) {
   let nr = gosNREUM();
-  const externallySupplied = nr.initializedAgents || {};
-  const curr = externallySupplied[id] || {};
-  if (!Object.keys(curr).length) {
-    curr.initializedAt = {
-      ms: now(),
-      date: new Date()
-    };
-  }
-  nr.initializedAgents = {
-    ...externallySupplied,
-    [id]: {
-      ...curr,
-      [target]: obj
-    }
+  nr.initializedAgents ??= {};
+  newAgentInstance.initializedAt = {
+    ms: now(),
+    date: new Date()
   };
-  return nr;
+  nr.initializedAgents[id] = newAgentInstance;
+}
+
+/**
+ * Get the agent instance under the associated identifier on the global newrelic object.
+ * @see setNREUMInitializedAgents
+ * @returns Existing agent instance under newrelic.initializedAgent[id], or undefined if it does not exist.
+ */
+export function getNREUMInitializedAgent(id) {
+  let nr = gosNREUM();
+  return nr.initializedAgents?.[id];
 }
 export function addToNREUM(fnName, fn) {
   let nr = gosNREUM();

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

@@ -63,10 +63,12 @@ export class Aggregate extends AggregateBase {
     } = getRuntime(this.agentIdentifier);
     if (loaderType) this.storeSupportabilityMetrics("Generic/LoaderType/".concat(loaderType, "/Detected"));
     if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
-
-    // frameworks on page
     if (isBrowserScope) {
       this.storeSupportabilityMetrics('Generic/Runtime/Browser/Detected');
+      const nonce = document?.currentScript?.nonce;
+      if (nonce && nonce !== '') {
+        this.storeSupportabilityMetrics('Generic/Runtime/Nonce/Detected');
+      }
 
       // These SMs are used by the AppExp team
       onDOMContentLoaded(() => {

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

@@ -25,6 +25,7 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { handle } from '../../../common/event-emitter/handle';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { RRWEB_VERSION } from "../../../common/constants/env.npm";
+import { now } from '../../../common/timing/now';
 export const AVG_COMPRESSION = 0.12;
 export const RRWEB_EVENT_TYPES = {
   DomContentLoaded: 0,
@@ -111,6 +112,9 @@ export class Aggregate extends AggregateBase {
 
     /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
     this.lastMeta = undefined;
+
+    /** set by BCS response */
+    this.entitled = false;
     const shouldSetup = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true && getConfigurationValue(agentIdentifier, 'session_trace.enabled') === true;
 
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
@@ -148,6 +152,18 @@ export class Aggregate extends AggregateBase {
         getPayload: this.prepareHarvest.bind(this),
         raw: true
       }, this);
+      registerHandler('recordReplay', () => {
+        // if it has aborted or BCS returned bad entitlements, do not allow
+        if (this.blocked || !this.entitled) return;
+        // if it isnt already (fully) initialized... initialize it
+        if (!recorder) this.initializeRecording(false, true, true);
+        // its been initialized and imported the recorder but its not recording (mode === off || error)
+        else if (this.mode !== MODE.FULL) this.switchToFull();
+        // if it gets all the way to here, that means a full session is already recording... do nothing
+      }, this.featureName, this.ee);
+      registerHandler('pauseReplay', () => {
+        this.forceStop(this.mode !== MODE.ERROR);
+      }, this.featureName, this.ee);
 
       // Wait for an error to be reported.  This currently is wrapped around the "Error" feature.  This is a feature-feature dependency.
       // This was to ensure that all errors, including those on the page before load and those handled with "noticeError" are accounted for. Needs evalulation
@@ -156,37 +172,42 @@ export class Aggregate extends AggregateBase {
         this.errorNoticed = true;
         // run once
         if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
-          this.mode = MODE.FULL;
-          // if the error was noticed AFTER the recorder was already imported....
-          if (recorder && this.initialized) {
-            this.stopRecording();
-            this.startRecording();
-            this.scheduler.startTimer(this.harvestTimeSeconds);
-            this.syncWithSessionManager({
-              sessionReplayMode: this.mode
-            });
-          }
+          this.switchToFull();
         }
       }, this.featureName, this.ee);
       this.waitForFlags(['sr']).then(_ref => {
         let [flagOn] = _ref;
-        return this.initializeRecording(flagOn, Math.random() * 100 < getConfigurationValue(this.agentIdentifier, 'session_replay.error_sampling_rate'), Math.random() * 100 < getConfigurationValue(this.agentIdentifier, 'session_replay.sampling_rate'));
+        this.entitled = flagOn;
+        this.initializeRecording(Math.random() * 100 < getConfigurationValue(this.agentIdentifier, 'session_replay.error_sampling_rate'), Math.random() * 100 < getConfigurationValue(this.agentIdentifier, 'session_replay.sampling_rate'));
       }).then(() => sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
 
       this.drain();
     }
   }
+  switchToFull() {
+    this.mode = MODE.FULL;
+    // if the error was noticed AFTER the recorder was already imported....
+    if (recorder && this.initialized) {
+      this.stopRecording();
+      this.startRecording();
+      this.scheduler.startTimer(this.harvestTimeSeconds);
+      this.syncWithSessionManager({
+        sessionReplayMode: this.mode
+      });
+    }
+  }
 
   /**
    * 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} errorSample - the true/false state of the error sampling decision
    * @param {boolean} fullSample - the true/false state of the full sampling decision
+   * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
-  async initializeRecording(entitlements, errorSample, fullSample) {
+  async initializeRecording(errorSample, fullSample, ignoreSession) {
     this.initialized = true;
-    if (!entitlements) return;
+    if (!this.entitled || this.recording) return;
     const {
       session
     } = getRuntime(this.agentIdentifier);
@@ -196,7 +217,7 @@ export class Aggregate extends AggregateBase {
     // we are not actively recording SR... DO NOT import or run the recording library
     // session replay samples can only be decided on the first load of a session
     // session replays can continue if already in progress
-    if (!session.isNew) {
+    if (!session.isNew && !ignoreSession) {
       // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode;
     } else {
@@ -287,10 +308,12 @@ export class Aggregate extends AggregateBase {
       this.events = this.events.slice(0, this.events.length - 1);
       this.hasMeta = !!this.events.find(x => x.type === RRWEB_EVENT_TYPES.Meta);
     }
+    const agentOffset = getRuntime(this.agentIdentifier).offset;
+    const relativeNow = now();
     const firstEventTimestamp = this.events[0]?.timestamp; // from rrweb node
     const lastEventTimestamp = this.events[this.events.length - 1]?.timestamp; // from rrweb node
     const firstTimestamp = firstEventTimestamp || this.cycleTimestamp;
-    const lastTimestamp = lastEventTimestamp || getRuntime(this.agentIdentifier).offset + globalScope.performance.now();
+    const lastTimestamp = lastEventTimestamp || agentOffset + relativeNow;
     return {
       qs: {
         browser_monitoring_key: info.licenseKey,
@@ -302,17 +325,20 @@ export class Aggregate extends AggregateBase {
             content_encoding: 'gzip'
           }),
           'replay.firstTimestamp': firstTimestamp,
+          'replay.firstTimestampOffset': firstTimestamp - agentOffset,
           'replay.lastTimestamp': lastTimestamp,
           'replay.durationMs': lastTimestamp - firstTimestamp,
           'replay.nodes': this.events.length,
+          'session.durationMs': agentRuntime.session.getDuration(),
           agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
+          rst: relativeNow,
           hasMeta: this.hasMeta,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
           isFirstChunk: agentRuntime.session.state.sessionReplaySentFirstChunk === false,
           decompressedBytes: this.payloadBytesEstimation,
-          'nr.rrweb.version': RRWEB_VERSION
+          'rrweb.version': RRWEB_VERSION
         }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
       },
 
@@ -439,6 +465,20 @@ export class Aggregate extends AggregateBase {
     return this.estimateCompression(this.payloadBytesEstimation + newBytes) + 1000;
   }
 
+  /**
+   * Forces the agent into OFF mode so that changing tabs or navigating
+   * does not restart the recording. This is used when the customer calls
+   * the stopRecording API.
+   */
+  forceStop(forceHarvest) {
+    if (forceHarvest) this.scheduler.runHarvest();
+    this.mode = MODE.OFF;
+    this.stopRecording();
+    this.syncWithSessionManager({
+      sessionReplayMode: this.mode
+    });
+  }
+
   /** Abort the feature, once aborted it will not resume */
   abort() {
     let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};