@newrelic/browser-agent 1.234.0 → 1.236.0

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

@@ -3,11 +3,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { submitData } from '../util/submit-data';
+import * as submitData from '../util/submit-data';
 import { SharedContext } from '../context/shared-context';
-import { Harvest, getSubmitMethod } from './harvest';
+import { Harvest } from './harvest';
 import { subscribeToEOL } from '../unload/eol';
 import { getConfigurationValue } from '../config/config';
+import { SESSION_EVENTS } from '../session/session-entity';
 
 /**
  * Periodically invokes harvest calls and handles retries
@@ -37,9 +38,18 @@ export class HarvestScheduler extends SharedContext {
     // unload if EOL mechanism fires
     subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
 
-    // unload if session resets
-    this.sharedContext?.ee.on('session-reset', this.unload.bind(this));
+    /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
+      Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under
+      the wrong session ID. */
+    this.sharedContext?.ee.on(SESSION_EVENTS.RESET, () => this.runHarvest({
+      forceNoRetry: true
+    }));
   }
+
+  /**
+   * This function is only meant for the last outgoing harvest cycle of a page. It trickles down to using sendBeacon, which should not be used
+   * to send payloads while the page is still active, due to limitations on how much data can be buffered in the API at any one time.
+   */
   unload() {
     if (this.aborted) return;
     // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
@@ -63,26 +73,36 @@ export class HarvestScheduler extends SharedContext {
   }
   scheduleHarvest(delay, opts) {
     if (this.timeoutHandle) return;
-    var timer = this;
     if (delay == null) {
       delay = this.interval;
     }
     this.timeoutHandle = setTimeout(() => {
-      timer.timeoutHandle = null;
-      timer.runHarvest(opts);
+      this.timeoutHandle = null;
+      this.runHarvest(opts);
     }, delay * 1000);
   }
   runHarvest(opts) {
     if (this.aborted) return;
-    var scheduler = this;
+
+    /**
+     * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
+     * @param {Object} result
+     */
+    const cbRanAfterSend = result => {
+      if (opts?.forceNoRetry) result.retry = false; // discard unsent data rather than re-queuing for next harvest attempt
+      this.onHarvestFinished(opts, result);
+    };
     let harvests = [];
     let submitMethod;
+    let payload;
     if (this.opts.getPayload) {
-      // Ajax & PVT & SR
-      submitMethod = getSubmitMethod(this.endpoint, opts);
+      // Ajax & PVT & SR features provide a callback function to get data for harvesting
+      submitMethod = submitData.getSubmitMethod({
+        isFinalHarvest: opts?.unload
+      });
       if (!submitMethod) return false;
-      const retry = submitMethod.method === submitData.xhr;
-      var payload = this.opts.getPayload({
+      const retry = !opts?.unload && submitMethod === submitData.xhr;
+      payload = this.opts.getPayload({
         retry: retry
       });
       if (!payload) {
@@ -111,7 +131,7 @@ export class HarvestScheduler extends SharedContext {
         payload,
         opts,
         submitMethod,
-        cbFinished: onHarvestFinished,
+        cbFinished: cbRanAfterSend,
         customUrl: this.opts.customUrl,
         raw: this.opts.raw
       });
@@ -120,16 +140,13 @@ export class HarvestScheduler extends SharedContext {
       this.scheduleHarvest();
     }
     return;
-    function onHarvestFinished(result) {
-      if (result.blocked) scheduler.onHarvestBlocked(opts, result);else scheduler.onHarvestFinished(opts, result);
-    }
   }
   onHarvestFinished(opts, result) {
     if (this.opts.onFinished) {
       this.opts.onFinished(result);
     }
     if (result.sent && result.retry) {
-      var delay = result.delay || this.opts.retryDelay;
+      const delay = result.delay || this.opts.retryDelay;
       // reschedule next harvest if should be delayed longer
       if (this.started && delay) {
         clearTimeout(this.timeoutHandle);

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

@@ -3,10 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { mapOwn } from '../util/map-own';
 import { obj as encodeObj, param as encodeParam } from '../url/encode';
 import { stringify } from '../util/stringify';
-import { submitData } from '../util/submit-data';
+import * as submitData from '../util/submit-data';
 import { getLocation } from '../url/location';
 import { getInfo, getConfigurationValue, getRuntime } from '../config/config';
 import { cleanURL } from '../url/clean-url';
@@ -16,27 +15,16 @@ import { Obfuscator } from '../util/obfuscate';
 import { applyFnToProps } from '../util/traverse';
 import { SharedContext } from '../context/shared-context';
 import { VERSION } from "../constants/env.npm";
-import { isBrowserScope, isWorkerScope } from '../util/global-scope';
+import { isWorkerScope, isIE } from '../constants/runtime';
 
 /**
- * @typedef {object} NetworkSendSpec
- * @param {string} endpoint The endpoint to use (jserrors, events, resources etc.)
- * @param {object} payload Object representing payload.
- * @param {object} payload.qs Map of values that should be sent as part of the request query string.
- * @param {string} payload.body String that should be sent as the body of the request.
- * @param {string} payload.body.e Special case of body used for browser interactions.
- * @param {object} opts Additional options for sending data
- * @param {boolean} opts.needResponse Specify whether the caller expects a response data.
- * @param {boolean} opts.unload Specify whether the call is a final harvest during page unload.
- * @param {boolean} opts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
- * @param {function} submitMethod The submit method to use {@link ../util/submit-data}
- * @param {string} customUrl Override the beacon url the data is sent to; must include protocol if defined
- * @param {boolean} gzip Enabled gzip compression on the body of the request before it is sent
- * @param {boolean} includeBaseParams Enables the use of base query parameters in the beacon url {@see Harvest.baseQueryString}
+ * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
+ * @typedef {import('./types.js').HarvestEndpointIdentifier} HarvestEndpointIdentifier
+ * @typedef {import('./types.js').HarvestPayload} HarvestPayload
+ * @typedef {import('./types.js').FeatureHarvestCallback} FeatureHarvestCallback
+ * @typedef {import('./types.js').FeatureHarvestCallbackOptions} FeatureHarvestCallbackOptions
  */
 
-const haveSendBeacon = !!navigator.sendBeacon; // only the web window obj has sendBeacon at this time, so 'false' for other envs
-
 export class Harvest extends SharedContext {
   constructor(parent) {
     super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
@@ -50,20 +38,19 @@ export class Harvest extends SharedContext {
   /**
    * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
    * name is emitted, which gives any listeners the opportunity to provide payload data.
+   * Note: Used by page_action
    * @param {NetworkSendSpec} spec Specification for sending data
    */
-  sendX(spec) {
-    const {
-      endpoint,
-      opts
-    } = spec;
-    var submitMethod = getSubmitMethod(endpoint, opts);
-    if (!submitMethod) return false;
-    var options = {
-      retry: submitMethod.method === submitData.xhr
+  sendX() {
+    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const submitMethod = submitData.getSubmitMethod({
+      isFinalHarvest: spec.opts?.unload
+    });
+    const options = {
+      retry: !spec.opts?.unload && submitMethod === submitData.xhr
     };
-    const payload = this.createPayload(endpoint, options);
-    var caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+    const payload = this.createPayload(spec.endpoint, options);
+    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
     return caller({
       ...spec,
       payload,
@@ -75,31 +62,19 @@ export class Harvest extends SharedContext {
    * Initiate a harvest call.
    * @param {NetworkSendSpec} spec Specification for sending data
    */
-  send(spec) {
-    const {
-      payload = {}
-    } = spec;
-    var makeBody = createAccumulator();
-    var makeQueryString = createAccumulator();
-    if (payload.body) mapOwn(payload.body, makeBody);
-    if (payload.qs) mapOwn(payload.qs, makeQueryString);
-    var newPayload = {
-      body: makeBody(),
-      qs: makeQueryString()
-    };
-    var caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
-    return caller({
-      ...spec,
-      payload: newPayload
-    });
+  send() {
+    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+    return caller(spec);
   }
 
   /**
    * Apply obfuscation rules to the payload and then initial the harvest network call.
    * @param {NetworkSendSpec} spec Specification for sending data
    */
-  obfuscateAndSend(spec) {
+  obfuscateAndSend() {
     var _this = this;
+    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const {
       payload = {}
     } = spec;
@@ -111,6 +86,14 @@ export class Harvest extends SharedContext {
       payload
     });
   }
+
+  /**
+   * Initiate a harvest call. Typically used by `sendX` and `send` methods or called directly
+   * for raw network calls.
+   * @param {NetworkSendSpec} param0 Specification for sending data
+   * @returns {boolean} True if the network call succeeded. For final harvest calls, the return
+   * value should not be relied upon because network calls will be made asynchronously.
+   */
   _send(_ref) {
     let {
       endpoint,
@@ -122,10 +105,14 @@ export class Harvest extends SharedContext {
       raw,
       includeBaseParams = true
     } = _ref;
-    var info = getInfo(this.sharedContext.agentIdentifier);
+    const info = getInfo(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
-    var agentRuntime = getRuntime(this.sharedContext.agentIdentifier);
-    if (!payload.body && !opts?.sendEmptyBody) {
+    const agentRuntime = getRuntime(this.sharedContext.agentIdentifier);
+    let {
+      body,
+      qs
+    } = this.cleanPayload(payload);
+    if (Object.keys(body).length === 0 && !opts?.sendEmptyBody) {
       // no payload body? nothing to send, just run onfinish stuff and return
       if (cbFinished) {
         cbFinished({
@@ -134,27 +121,32 @@ export class Harvest extends SharedContext {
       }
       return false;
     }
-    let url = '';
-    if (customUrl) url = customUrl;else if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);else url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpoint !== 'rum' ? "/".concat(endpoint) : '', "/1/").concat(info.licenseKey);
-    var baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
-    var payloadParams = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : '';
+    let url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpoint !== 'rum' ? "/".concat(endpoint) : '', "/1/").concat(info.licenseKey);
+    if (customUrl) url = customUrl;
+    if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);
+    const baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
+    let payloadParams = encodeObj(qs, agentRuntime.maxBytes);
     if (!submitMethod) {
-      submitMethod = getSubmitMethod(endpoint, opts);
+      submitMethod = submitData.getSubmitMethod({
+        isFinalHarvest: opts.unload
+      });
+    }
+    if (baseParams === '' && payloadParams.startsWith('&')) {
+      payloadParams = payloadParams.substring(1);
     }
-    var method = submitMethod.method;
-    var useBody = submitMethod.useBody;
-    var body;
-    var fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
-    const gzip = payload?.qs?.content_encoding === 'gzip';
+    const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
+    const gzip = qs.content_encoding === 'gzip';
     if (!gzip) {
-      if (useBody && endpoint === 'events') {
-        body = payload.body.e;
-      } else if (useBody) {
-        body = stringify(payload.body);
+      if (endpoint === 'events') {
+        body = body.e;
       } else {
-        fullUrl = fullUrl + encodeObj(payload.body, agentRuntime.maxBytes);
+        body = stringify(body);
       }
-    } else body = payload.body;
+    }
+    if (!body || body.length === 0 || body === '{}' || body === '[]') {
+      // If body is null, undefined, or an empty object or array, send an empty string instead
+      body = '';
+    }
 
     // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
@@ -166,101 +158,141 @@ export class Harvest extends SharedContext {
       value: 'text/plain'
     });
 
-    /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
+    /* Since workers don't support sendBeacon right now, they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
-        we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */
-
-    var result = method({
+        we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
+       Following the removal of img-element method, IE will also use sync XHR on page dismissal to ensure final analytics are sent. */
+    let result = submitMethod({
       url: fullUrl,
       body,
-      sync: opts.unload && isWorkerScope,
+      sync: opts.unload && (isWorkerScope || isIE),
       headers
     });
-    if (cbFinished && method === submitData.xhr) {
-      var xhr = result;
-      xhr.addEventListener('load', function () {
-        var result = {
+    if (!opts.unload && cbFinished && submitMethod === submitData.xhr) {
+      const harvestScope = this;
+      result.addEventListener('load', function () {
+        // `this` refers to the XHR object in this scope, do not change this to a fat arrow
+        const cbResult = {
           sent: true,
           status: this.status
         };
         if (this.status === 429) {
-          result.retry = true;
-          result.delay = this.tooManyRequestsDelay;
+          cbResult.retry = true;
+          cbResult.delay = harvestScope.tooManyRequestsDelay;
         } else if (this.status === 408 || this.status === 500 || this.status === 503) {
-          result.retry = true;
+          cbResult.retry = true;
         }
         if (opts.needResponse) {
-          result.responseText = this.responseText;
+          cbResult.responseText = this.responseText;
         }
-        cbFinished(result);
+        cbFinished(cbResult);
       }, eventListenerOpts(false));
     }
 
     // if beacon request failed, retry with an alternative method -- will not happen for workers
-    if (!result && method === submitData.beacon) {
-      method = submitData.img;
-      result = method({
-        url: fullUrl + encodeObj(payload.body, agentRuntime.maxBytes)
-      });
+    if (!result && submitMethod === submitData.beacon) {
+      // browsers that support sendBeacon also support fetch with keepalive - IE will not retry unload calls
+      submitMethod = submitData.fetchKeepAlive;
+      try {
+        submitMethod({
+          url: fullUrl,
+          body,
+          headers
+        });
+      } catch (e) {
+        // Ignore error in final harvest
+      } finally {
+        result = true;
+      }
     }
     return result;
   }
 
   // The stuff that gets sent every time.
   baseQueryString() {
-    var runtime = getRuntime(this.sharedContext.agentIdentifier);
-    var info = getInfo(this.sharedContext.agentIdentifier);
-    var location = cleanURL(getLocation());
-    var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
+    const runtime = getRuntime(this.sharedContext.agentIdentifier);
+    const info = getInfo(this.sharedContext.agentIdentifier);
+    const location = cleanURL(getLocation());
+    const ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
     return ['a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
     '&s=' + (runtime.session?.state.value || '0'),
     // the 0 id encaps all untrackable and default traffic
     encodeParam('ref', ref), encodeParam('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
   }
-  createPayload(type, options) {
-    var makeBody = createAccumulator();
-    var makeQueryString = createAccumulator();
-    var listeners = this._events[type] && this._events[type] || [];
-    for (var i = 0; i < listeners.length; i++) {
-      var singlePayload = listeners[i](options);
-      if (!singlePayload) continue;
-      if (singlePayload.body) mapOwn(singlePayload.body, makeBody);
-      if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString);
+
+  /**
+   * Calls and accumulates data from registered harvesting functions based on
+   * the endpoint being harvested.
+   * @param {HarvestEndpointIdentifier} endpoint BAM endpoint identifier.
+   * @param {FeatureHarvestCallbackOptions} options Options to be passed to the
+   * feature harvest listener callback.
+   * @returns {HarvestPayload} Payload object to transmit to the bam endpoint.
+   */
+  createPayload(endpoint, options) {
+    const listeners = this._events[endpoint];
+    const payload = {
+      body: {},
+      qs: {}
+    };
+    if (Array.isArray(listeners) && listeners.length > 0) {
+      for (let i = 0; i < listeners.length; i++) {
+        const singlePayload = listeners[i](options);
+        if (singlePayload) {
+          payload.body = {
+            ...payload.body,
+            ...(singlePayload.body || {})
+          };
+          payload.qs = {
+            ...payload.qs,
+            ...(singlePayload.qs || {})
+          };
+        }
+      }
     }
+    return payload;
+  }
+
+  /**
+   * Cleans and returns a payload object containing a body and qs
+   * object with key/value pairs. KV pairs where the value is null,
+   * undefined, or an empty string are removed to save on transmission
+   * size.
+   * @param {HarvestPayload} payload Payload to be sent to the endpoint.
+   * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
+   */
+  cleanPayload() {
+    let payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const clean = input => {
+      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) {
+        return input.length > 0 ? input : null;
+      }
+      return Object.entries(input || {}).reduce((accumulator, _ref2) => {
+        let [key, value] = _ref2;
+        if (typeof value === 'number' || typeof value === 'string' && value.length > 0 || typeof value === 'object' && Object.keys(value || {}).length > 0) {
+          accumulator[key] = value;
+        }
+        return accumulator;
+      }, {});
+    };
     return {
-      body: makeBody(),
-      qs: makeQueryString()
+      body: clean(payload.body),
+      qs: clean(payload.qs)
     };
   }
-  on(type, listener) {
-    var listeners = this._events[type] || (this._events[type] = []);
-    listeners.push(listener);
-  }
-  resetListeners() {
-    mapOwn(this._events, key => {
-      this._events[key] = [];
-    });
-  }
-}
-export function getSubmitMethod(endpoint, opts) {
-  opts = opts || {};
-  var method;
-  var useBody;
-  if (opts.unload && isBrowserScope) {
-    // all the features' final harvest; neither methods work outside window context
-    useBody = haveSendBeacon;
-    method = haveSendBeacon ? submitData.beacon : submitData.img; // really only IE doesn't have Beacon API for web browsers
-  } else {
-    // `submitData.beacon` was removed, there is an upper limit to the
-    // number of data allowed before it starts failing, so we save it only for page unloading
-    useBody = true;
-    method = submitData.xhr;
+
+  /**
+   * Registers a function to be called when harvesting is triggered for a specific
+   * endpoint.
+   * @param {HarvestEndpointIdentifier} endpoint
+   * @param {FeatureHarvestCallback} listener
+   */
+  on(endpoint, listener) {
+    if (!Array.isArray(this._events[endpoint])) {
+      this._events[endpoint] = [];
+    }
+    this._events[endpoint].push(listener);
   }
-  return {
-    method: method,
-    useBody: useBody
-  };
 }
 
 // Constructs the transaction name param for the beacon URL.
@@ -269,18 +301,4 @@ export function getSubmitMethod(endpoint, opts) {
 function transactionNameParam(info) {
   if (info.transactionName) return encodeParam('to', info.transactionName);
   return encodeParam('t', info.tNamePlain || 'Unnamed Transaction');
-}
-
-// returns a function that can be called to accumulate values to a single object
-// when the function is called without parameters, then the accumulator is returned
-function createAccumulator() {
-  var accumulator = {};
-  var hasData = false;
-  return function (key, val) {
-    if (val !== null && val !== undefined && val.toString()?.length) {
-      accumulator[key] = val;
-      hasData = true;
-    }
-    if (hasData) return accumulator;
-  };
 }

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

@@ -0,0 +1,47 @@
+/**
+ * @file Contains types related to harvesting data.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+/**
+ * @typedef {'rum'|'jserrors'|'events'|'ins'|'resources'|'blob'} HarvestEndpointIdentifier
+ */
+
+/**
+ * @typedef {object} HarvestPayload
+ * @property {object} qs Map of values that should be sent as part of the request query string.
+ * @property {object} body Map of values that should be sent as the body of the request.
+ * @property {string} body.e Special case of body used for browser interactions.
+ */
+
+/**
+ * @typedef {object} FeatureHarvestCallbackOptions Options for aggregating data for harvesting.
+ * @property {boolean} options.retry Indicates if the feature should store the aggregated
+ * data in anticipation of a possible need to retry the transmission.
+ */
+
+/**
+ * @callback FeatureHarvestCallback
+ * @param {FeatureHarvestCallbackOptions} options Options for aggregating data for harvesting.
+ * @returns {HarvestPayload} Payload of data to transmit to bam endpoint.
+ */
+
+/**
+ * @typedef {object} NetworkSendSpec
+ * @property {HarvestEndpointIdentifier} endpoint The endpoint to use (jserrors, events, resources etc.)
+ * @property {HarvestPayload} payload Object representing payload.
+ * @property {object} opts Additional options for sending data
+ * @property {boolean} opts.needResponse Specify whether the caller expects a response data.
+ * @property {boolean} opts.unload Specify whether the call is a final harvest during page unload.
+ * @property {boolean} opts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
+ * @property {boolean} opts.retry Indicates if the feature should store the aggregated data in anticipation of a possible need to
+ * retry the transmission.
+ * @property {import('../util/submit-data.js').NetworkMethods} submitMethod The network method to use {@link ../util/submit-data.js}
+ * @property {string} customUrl Override the beacon url the data is sent to; must include protocol if defined
+ * @property {boolean} raw If true, disables adding the license key to the url
+ * @property {boolean} includeBaseParams Enables the use of base query parameters in the beacon url
+ */
+
+/* istanbul ignore next */
+export const unused = {};

package/dist/esm/common/ids/id.js

@@ -4,7 +4,7 @@
  */
 
 import { getOrSet } from '../util/get-or-set';
-import { globalScope } from '../util/global-scope';
+import { globalScope } from '../constants/runtime';
 
 // Start assigning ids at 1 so 0 can always be used for Window or WorkerGlobalScope, without
 // actually setting it (which would create a global variable).

package/dist/esm/common/ids/unique-id.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { globalScope } from '../util/global-scope';
+import { globalScope } from '../constants/runtime';
 const uuidv4Template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 
 /**