ref(browser): Make attachStacktrace usage more explicit

packages/browser/src/backend.ts

@@ -40,13 +40,13 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
    * @inheritDoc
    */
   public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
-    return eventFromException(this._options, exception, hint);
+    return eventFromException(exception, hint, this._options.attachStacktrace);
   }
   /**
    * @inheritDoc
    */
   public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {
-    return eventFromMessage(this._options, message, level, hint);
+    return eventFromMessage(message, level, hint, this._options.attachStacktrace);
   }
 
   /**

packages/browser/src/eventbuilder.ts

@@ -1,4 +1,4 @@
-import { Event, EventHint, Options, Severity } from '@sentry/types';
+import { Event, EventHint, Severity } from '@sentry/types';
 import {
   addExceptionMechanism,
   addExceptionTypeValue,
@@ -17,11 +17,13 @@ import { eventFromError, eventFromPlainObject, parseStackFrames } from './parser
  * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
  * @hidden
  */
-export function eventFromException(options: Options, exception: unknown, hint?: EventHint): PromiseLike<Event> {
+export function eventFromException(
+  exception: unknown,
+  hint?: EventHint,
+  attachStacktrace?: boolean,
+): PromiseLike<Event> {
   const syntheticException = (hint && hint.syntheticException) || undefined;
-  const event = eventFromUnknownInput(exception, syntheticException, {
-    attachStacktrace: options.attachStacktrace,
-  });
+  const event = eventFromUnknownInput(exception, syntheticException, attachStacktrace);
   addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
   event.level = Severity.Error;
   if (hint && hint.event_id) {
@@ -35,15 +37,13 @@ export function eventFromException(options: Options, exception: unknown, hint?:
  * @hidden
  */
 export function eventFromMessage(
-  options: Options,
   message: string,
   level: Severity = Severity.Info,
   hint?: EventHint,
+  attachStacktrace?: boolean,
 ): PromiseLike<Event> {
   const syntheticException = (hint && hint.syntheticException) || undefined;
-  const event = eventFromString(message, syntheticException, {
-    attachStacktrace: options.attachStacktrace,
-  });
+  const event = eventFromString(message, syntheticException, attachStacktrace);
   event.level = level;
   if (hint && hint.event_id) {
     event.event_id = hint.event_id;
@@ -57,10 +57,8 @@ export function eventFromMessage(
 export function eventFromUnknownInput(
   exception: unknown,
   syntheticException?: Error,
-  options: {
-    isRejection?: boolean;
-    attachStacktrace?: boolean;
-  } = {},
+  attachStacktrace?: boolean,
+  isUnhandledRejection?: boolean,
 ): Event {
   let event: Event;
 
@@ -85,7 +83,7 @@ export function eventFromUnknownInput(
     } else {
       const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
       const message = domException.message ? `${name}: ${domException.message}` : name;
-      event = eventFromString(message, syntheticException, options);
+      event = eventFromString(message, syntheticException, attachStacktrace);
       addExceptionTypeValue(event, message);
     }
     if ('code' in domException) {
@@ -103,7 +101,7 @@ export function eventFromUnknownInput(
     // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
     // group on any key/value change.
     const objectException = exception as Record<string, unknown>;
-    event = eventFromPlainObject(objectException, syntheticException, options.isRejection);
+    event = eventFromPlainObject(objectException, syntheticException, isUnhandledRejection);
     addExceptionMechanism(event, {
       synthetic: true,
     });
@@ -119,7 +117,7 @@ export function eventFromUnknownInput(
   // - a plain Object
   //
   // So bail out and capture it as a simple message:
-  event = eventFromString(exception as string, syntheticException, options);
+  event = eventFromString(exception as string, syntheticException, attachStacktrace);
   addExceptionTypeValue(event, `${exception}`, undefined);
   addExceptionMechanism(event, {
     synthetic: true,
@@ -131,18 +129,12 @@ export function eventFromUnknownInput(
 /**
  * @hidden
  */
-export function eventFromString(
-  input: string,
-  syntheticException?: Error,
-  options: {
-    attachStacktrace?: boolean;
-  } = {},
-): Event {
+export function eventFromString(input: string, syntheticException?: Error, attachStacktrace?: boolean): Event {
   const event: Event = {
     message: input,
   };
 
-  if (options.attachStacktrace && syntheticException) {
+  if (attachStacktrace && syntheticException) {
     const frames = parseStackFrames(syntheticException);
     if (frames.length) {
       event.stacktrace = { frames };

packages/browser/src/integrations/globalhandlers.ts

@@ -92,10 +92,7 @@ function _installGlobalOnErrorHandler(): void {
         error === undefined && isString(msg)
           ? _eventFromIncompleteOnError(msg, url, line, column)
           : _enhanceEventWithInitialFrame(
-              eventFromUnknownInput(error || msg, undefined, {
-                attachStacktrace,
-                isRejection: false,
-              }),
+              eventFromUnknownInput(error || msg, undefined, attachStacktrace, false),
               url,
               line,
               column,
@@ -145,10 +142,7 @@ function _installGlobalOnUnhandledRejectionHandler(): void {
 
       const event = isPrimitive(error)
         ? _eventFromRejectionWithPrimitive(error)
-        : eventFromUnknownInput(error, undefined, {
-            attachStacktrace,
-            isRejection: true,
-          });
+        : eventFromUnknownInput(error, undefined, attachStacktrace, true);
 
       event.level = Severity.Error;
 

packages/browser/src/parsers.ts

@@ -35,15 +35,15 @@ export function exceptionFromError(ex: Error): Exception {
 export function eventFromPlainObject(
   exception: Record<string, unknown>,
   syntheticException?: Error,
-  rejection?: boolean,
+  isUnhandledRejection?: boolean,
 ): Event {
   const event: Event = {
     exception: {
       values: [
         {
-          type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',
+          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
           value: `Non-Error ${
-            rejection ? 'promise rejection' : 'exception'
+            isUnhandledRejection ? 'promise rejection' : 'exception'
           } captured with keys: ${extractExceptionKeysForMessage(exception)}`,
         },
       ],