@sentry/core 10.53.1 → 10.54.0

package/build/cjs/scope.js

@@ -12,70 +12,10 @@ const spanOnScope = require('./utils/spanOnScope.js');
 const string = require('./utils/string.js');
 const time = require('./utils/time.js');
 
-/**
- * Default value for maximum number of breadcrumbs added to an event.
- */
 const DEFAULT_MAX_BREADCRUMBS = 100;
-
-/**
- * A context to be used for capturing an event.
- * This can either be a Scope, or a partial ScopeContext,
- * or a callback that receives the current scope and returns a new scope to use.
- */
-
-/**
- * Holds additional event information.
- */
 class Scope {
-  /** Flag if notifying is happening. */
-
-  /** Callback for client to receive scope changes. */
-
-  /** Callback list that will be called during event processing. */
-
-  /** Array of breadcrumbs. */
-
-  /** User */
-
-  /** Tags */
-
-  /** Attributes */
-
-  /** Extra */
-
-  /** Contexts */
-
-  /** Attachments */
-
-  /** Propagation Context for distributed tracing */
-
-  /**
-   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
-   * sent to Sentry
-   */
-
-  /** Fingerprint */
-
-  /** Severity */
-
-  /**
-   * Transaction Name
-   *
-   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
-   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
-   */
-
-  /** Session */
-
-  /** The client on this scope */
-
-  /** Contains the last event id of a captured event.  */
-
-  /** Conversation ID */
-
   // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
-
-   constructor() {
+  constructor() {
     this._notifyingListeners = false;
     this._scopeListeners = [];
     this._eventProcessors = [];
@@ -89,14 +29,13 @@ class Scope {
     this._sdkProcessingMetadata = {};
     this._propagationContext = {
       traceId: propagationContext.generateTraceId(),
-      sampleRand: randomSafeContext.safeMathRandom(),
+      sampleRand: randomSafeContext.safeMathRandom()
     };
   }
-
   /**
    * Clone all data from this scope into a new scope.
    */
-   clone() {
+  clone() {
     const newScope = new Scope();
     newScope._breadcrumbs = [...this._breadcrumbs];
     newScope._tags = { ...this._tags };
@@ -104,13 +43,10 @@ class Scope {
     newScope._extra = { ...this._extra };
     newScope._contexts = { ...this._contexts };
     if (this._contexts.flags) {
-      // We need to copy the `values` array so insertions on a cloned scope
-      // won't affect the original array.
       newScope._contexts.flags = {
-        values: [...this._contexts.flags.values],
+        values: [...this._contexts.flags.values]
       };
     }
-
     newScope._user = this._user;
     newScope._level = this._level;
     newScope._session = this._session;
@@ -123,118 +59,100 @@ class Scope {
     newScope._client = this._client;
     newScope._lastEventId = this._lastEventId;
     newScope._conversationId = this._conversationId;
-
     spanOnScope._setSpanForScope(newScope, spanOnScope._getSpanForScope(this));
-
     return newScope;
   }
-
   /**
    * Update the client assigned to this scope.
    * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,
    * as well as manually created scopes.
    */
-   setClient(client) {
+  setClient(client) {
     this._client = client;
   }
-
   /**
    * Set the ID of the last captured error event.
    * This is generally only captured on the isolation scope.
    */
-   setLastEventId(lastEventId) {
+  setLastEventId(lastEventId) {
     this._lastEventId = lastEventId;
   }
-
   /**
    * Get the client assigned to this scope.
    */
-   getClient() {
-    return this._client ;
+  getClient() {
+    return this._client;
   }
-
   /**
    * Get the ID of the last captured error event.
    * This is generally only available on the isolation scope.
    */
-   lastEventId() {
+  lastEventId() {
     return this._lastEventId;
   }
-
   /**
    * @inheritDoc
    */
-   addScopeListener(callback) {
+  addScopeListener(callback) {
     this._scopeListeners.push(callback);
   }
-
   /**
    * Add an event processor that will be called before an event is sent.
    */
-   addEventProcessor(callback) {
+  addEventProcessor(callback) {
     this._eventProcessors.push(callback);
     return this;
   }
-
   /**
    * Set the user for this scope.
    * Set to `null` to unset the user.
    */
-   setUser(user) {
-    // If null is passed we want to unset everything, but still define keys,
-    // so that later down in the pipeline any existing values are cleared.
+  setUser(user) {
     this._user = user || {
-      email: undefined,
-      id: undefined,
-      ip_address: undefined,
-      username: undefined,
+      email: void 0,
+      id: void 0,
+      ip_address: void 0,
+      username: void 0
     };
-
     if (this._session) {
       session.updateSession(this._session, { user });
     }
-
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Get the user from this scope.
    */
-   getUser() {
+  getUser() {
     return this._user;
   }
-
   /**
    * Set the conversation ID for this scope.
    * Set to `null` to unset the conversation ID.
    */
-   setConversationId(conversationId) {
-    this._conversationId = conversationId || undefined;
+  setConversationId(conversationId) {
+    this._conversationId = conversationId || void 0;
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Set an object that will be merged into existing tags on the scope,
    * and will be sent as tags data with the event.
    */
-   setTags(tags) {
+  setTags(tags) {
     this._tags = {
       ...this._tags,
-      ...tags,
+      ...tags
     };
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Set a single tag that will be sent as tags data with the event.
    */
-   setTag(key, value) {
+  setTag(key, value) {
     return this.setTags({ [key]: value });
   }
-
   /**
    * Sets attributes onto the scope.
    *
@@ -257,16 +175,14 @@ class Scope {
    * });
    * ```
    */
-   setAttributes(newAttributes) {
+  setAttributes(newAttributes) {
     this._attributes = {
       ...this._attributes,
-      ...newAttributes,
+      ...newAttributes
     };
-
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Sets an attribute onto the scope.
    *
@@ -288,13 +204,9 @@ class Scope {
    * ```
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-   setAttribute(
-    key,
-    value,
-  ) {
+  setAttribute(key, value) {
     return this.setAttributes({ [key]: value });
   }
-
   /**
    * Removes the attribute with the given key from the scope.
    *
@@ -305,56 +217,50 @@ class Scope {
    * scope.removeAttribute('is_admin');
    * ```
    */
-   removeAttribute(key) {
+  removeAttribute(key) {
     if (key in this._attributes) {
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete this._attributes[key];
       this._notifyScopeListeners();
     }
     return this;
   }
-
   /**
    * Set an object that will be merged into existing extra on the scope,
    * and will be sent as extra data with the event.
    */
-   setExtras(extras) {
+  setExtras(extras) {
     this._extra = {
       ...this._extra,
-      ...extras,
+      ...extras
     };
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Set a single key:value extra entry that will be sent as extra data with the event.
    */
-   setExtra(key, extra) {
+  setExtra(key, extra) {
     this._extra = { ...this._extra, [key]: extra };
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Sets the fingerprint on the scope to send with the events.
    * @param {string[]} fingerprint Fingerprint to group events in Sentry.
    */
-   setFingerprint(fingerprint) {
+  setFingerprint(fingerprint) {
     this._fingerprint = fingerprint;
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Sets the level on the scope for future events.
    */
-   setLevel(level) {
+  setLevel(level) {
     this._level = level;
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Sets the transaction name on the scope so that the name of e.g. taken server route or
    * the page location is attached to future events.
@@ -366,33 +272,29 @@ class Scope {
    * By default, the SDK updates the scope's transaction name automatically on sensible
    * occasions, such as a page navigation or when handling a new request on the server.
    */
-   setTransactionName(name) {
+  setTransactionName(name) {
     this._transactionName = name;
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Sets context data with the given name.
    * Data passed as context will be normalized. You can also pass `null` to unset the context.
    * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.
    */
-   setContext(key, context) {
+  setContext(key, context) {
     if (context === null) {
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete this._contexts[key];
     } else {
       this._contexts[key] = context;
     }
-
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Set the session for the scope.
    */
-   setSession(session) {
+  setSession(session) {
     if (!session) {
       delete this._session;
     } else {
@@ -401,34 +303,24 @@ class Scope {
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Get the session from the scope.
    */
-   getSession() {
+  getSession() {
     return this._session;
   }
-
   /**
    * Updates the scope with provided data. Can work in three variations:
    * - plain object containing updatable attributes
    * - Scope instance that'll extract the attributes from
    * - callback function that'll receive the current scope as an argument and allow for modifications
    */
-   update(captureContext) {
+  update(captureContext) {
     if (!captureContext) {
       return this;
     }
-
-    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;
-
-    const scopeInstance =
-      scopeToMerge instanceof Scope
-        ? scopeToMerge.getScopeData()
-        : is.isPlainObject(scopeToMerge)
-          ? (captureContext )
-          : undefined;
-
+    const scopeToMerge = typeof captureContext === "function" ? captureContext(this) : captureContext;
+    const scopeInstance = scopeToMerge instanceof Scope ? scopeToMerge.getScopeData() : is.isPlainObject(scopeToMerge) ? captureContext : void 0;
     const {
       tags,
       attributes,
@@ -438,131 +330,109 @@ class Scope {
       level,
       fingerprint = [],
       propagationContext,
-      conversationId,
+      conversationId
     } = scopeInstance || {};
-
     this._tags = { ...this._tags, ...tags };
     this._attributes = { ...this._attributes, ...attributes };
     this._extra = { ...this._extra, ...extra };
     this._contexts = { ...this._contexts, ...contexts };
-
     if (user && Object.keys(user).length) {
       this._user = user;
     }
-
     if (level) {
       this._level = level;
     }
-
     if (fingerprint.length) {
       this._fingerprint = fingerprint;
     }
-
     if (propagationContext) {
       this._propagationContext = propagationContext;
     }
-
     if (conversationId) {
       this._conversationId = conversationId;
     }
-
     return this;
   }
-
   /**
    * Clears the current scope and resets its properties.
    * Note: The client will not be cleared.
    */
-   clear() {
-    // client is not cleared here on purpose!
+  clear() {
     this._breadcrumbs = [];
     this._tags = {};
     this._attributes = {};
     this._extra = {};
     this._user = {};
     this._contexts = {};
-    this._level = undefined;
-    this._transactionName = undefined;
-    this._fingerprint = undefined;
-    this._session = undefined;
-    this._conversationId = undefined;
-    spanOnScope._setSpanForScope(this, undefined);
+    this._level = void 0;
+    this._transactionName = void 0;
+    this._fingerprint = void 0;
+    this._session = void 0;
+    this._conversationId = void 0;
+    spanOnScope._setSpanForScope(this, void 0);
     this._attachments = [];
     this.setPropagationContext({
       traceId: propagationContext.generateTraceId(),
-      sampleRand: randomSafeContext.safeMathRandom(),
+      sampleRand: randomSafeContext.safeMathRandom()
     });
-
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Adds a breadcrumb to the scope.
    * By default, the last 100 breadcrumbs are kept.
    */
-   addBreadcrumb(breadcrumb, maxBreadcrumbs) {
-    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
-
-    // No data has been changed, so don't notify scope listeners
+  addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+    const maxCrumbs = typeof maxBreadcrumbs === "number" ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
     if (maxCrumbs <= 0) {
       return this;
     }
-
     const mergedBreadcrumb = {
       timestamp: time.dateTimestampInSeconds(),
       ...breadcrumb,
       // Breadcrumb messages can theoretically be infinitely large and they're held in memory so we truncate them not to leak (too much) memory
-      message: breadcrumb.message ? string.truncate(breadcrumb.message, 2048) : breadcrumb.message,
+      message: breadcrumb.message ? string.truncate(breadcrumb.message, 2048) : breadcrumb.message
     };
-
     this._breadcrumbs.push(mergedBreadcrumb);
     if (this._breadcrumbs.length > maxCrumbs) {
       this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs);
-      this._client?.recordDroppedEvent('buffer_overflow', 'log_item');
+      this._client?.recordDroppedEvent("buffer_overflow", "log_item");
     }
-
     this._notifyScopeListeners();
-
     return this;
   }
-
   /**
    * Get the last breadcrumb of the scope.
    */
-   getLastBreadcrumb() {
+  getLastBreadcrumb() {
     return this._breadcrumbs[this._breadcrumbs.length - 1];
   }
-
   /**
    * Clear all breadcrumbs from the scope.
    */
-   clearBreadcrumbs() {
+  clearBreadcrumbs() {
     this._breadcrumbs = [];
     this._notifyScopeListeners();
     return this;
   }
-
   /**
    * Add an attachment to the scope.
    */
-   addAttachment(attachment) {
+  addAttachment(attachment) {
     this._attachments.push(attachment);
     return this;
   }
-
   /**
    * Clear all attachments from the scope.
    */
-   clearAttachments() {
+  clearAttachments() {
     this._attachments = [];
     return this;
   }
-
   /**
    * Get the data of this scope, which should be applied to an event during processing.
    */
-   getScopeData() {
+  getScopeData() {
     return {
       breadcrumbs: this._breadcrumbs,
       attachments: this._attachments,
@@ -578,77 +448,65 @@ class Scope {
       sdkProcessingMetadata: this._sdkProcessingMetadata,
       transactionName: this._transactionName,
       span: spanOnScope._getSpanForScope(this),
-      conversationId: this._conversationId,
+      conversationId: this._conversationId
     };
   }
-
   /**
    * Add data which will be accessible during event processing but won't get sent to Sentry.
    */
-   setSDKProcessingMetadata(newData) {
+  setSDKProcessingMetadata(newData) {
     this._sdkProcessingMetadata = merge.merge(this._sdkProcessingMetadata, newData, 2);
     return this;
   }
-
   /**
    * Add propagation context to the scope, used for distributed tracing
    */
-   setPropagationContext(context) {
+  setPropagationContext(context) {
     this._propagationContext = context;
     return this;
   }
-
   /**
    * Get propagation context from the scope, used for distributed tracing
    */
-   getPropagationContext() {
+  getPropagationContext() {
     return this._propagationContext;
   }
-
   /**
    * Capture an exception for this scope.
    *
    * @returns {string} The id of the captured Sentry event.
    */
-   captureException(exception, hint) {
+  captureException(exception, hint) {
     const eventId = hint?.event_id || misc.uuid4();
-
     if (!this._client) {
-      debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture exception!');
+      debugBuild.DEBUG_BUILD && debugLogger.debug.warn("No client configured on scope - will not capture exception!");
       return eventId;
     }
-
-    const syntheticException = new Error('Sentry syntheticException');
-
+    const syntheticException = new Error("Sentry syntheticException");
     this._client.captureException(
       exception,
       {
         originalException: exception,
         syntheticException,
         ...hint,
-        event_id: eventId,
+        event_id: eventId
       },
-      this,
+      this
     );
-
     return eventId;
   }
-
   /**
    * Capture a message for this scope.
    *
    * @returns {string} The id of the captured message.
    */
-   captureMessage(message, level, hint) {
+  captureMessage(message, level, hint) {
     const eventId = hint?.event_id || misc.uuid4();
-
     if (!this._client) {
-      debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture message!');
+      debugBuild.DEBUG_BUILD && debugLogger.debug.warn("No client configured on scope - will not capture message!");
       return eventId;
     }
-
     const syntheticException = hint?.syntheticException ?? new Error(message);
-
     this._client.captureMessage(
       message,
       level,
@@ -656,42 +514,33 @@ class Scope {
         originalException: message,
         syntheticException,
         ...hint,
-        event_id: eventId,
+        event_id: eventId
       },
-      this,
+      this
     );
-
     return eventId;
   }
-
   /**
    * Capture a Sentry event for this scope.
    *
    * @returns {string} The id of the captured event.
    */
-   captureEvent(event, hint) {
+  captureEvent(event, hint) {
     const eventId = event.event_id || hint?.event_id || misc.uuid4();
-
     if (!this._client) {
-      debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture event!');
+      debugBuild.DEBUG_BUILD && debugLogger.debug.warn("No client configured on scope - will not capture event!");
       return eventId;
     }
-
     this._client.captureEvent(event, { ...hint, event_id: eventId }, this);
-
     return eventId;
   }
-
   /**
    * This will be called on every set call.
    */
-   _notifyScopeListeners() {
-    // We need this check for this._notifyingListeners to be able to work on scope during updates
-    // If this check is not here we'll produce endless recursion when something is done with the scope
-    // during the callback.
+  _notifyScopeListeners() {
     if (!this._notifyingListeners) {
       this._notifyingListeners = true;
-      this._scopeListeners.forEach(callback => {
+      this._scopeListeners.forEach((callback) => {
         callback(this);
       });
       this._notifyingListeners = false;