use typeguard for isPrimitive and take advantage of that where possible

Author: lobsterkatie

packages/browser/src/integrations/globalhandlers.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { getCurrentHub } from '@sentry/core';
-import { Event, Integration, Severity } from '@sentry/types';
+import { Event, Integration, Primitive, Severity } from '@sentry/types';
 import {
   addExceptionMechanism,
   addInstrumentationHandler,
@@ -152,7 +152,7 @@ export class GlobalHandlers implements Integration {
 
         const client = currentHub.getClient();
         const event = isPrimitive(error)
-          ? this._eventFromIncompleteRejection(error)
+          ? this._eventFromRejectionWithPrimitive(error)
           : eventFromUnknownInput(error, undefined, {
               attachStacktrace: client && client.getOptions().attachStacktrace,
               rejection: true,
@@ -211,16 +211,20 @@ export class GlobalHandlers implements Integration {
   }
 
   /**
-   * This function creates an Event from an TraceKitStackTrace that has part of it missing.
+   * Create an event from a promise rejection where the `reason` is a primitive.
+   *
+   * @param reason: The `reason` property of the promise rejection
+   * @returns An Event object with an appropriate `exception` value
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private _eventFromIncompleteRejection(error: any): Event {
+  private _eventFromRejectionWithPrimitive(reason: Primitive): Event {
     return {
       exception: {
         values: [
           {
             type: 'UnhandledRejection',
-            value: `Non-Error promise rejection captured with value: ${error}`,
+            // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
+            value: `Non-Error promise rejection captured with value: ${String(reason)}`,
           },
         ],
       },

packages/core/src/baseclient.ts

@@ -119,7 +119,7 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
     let eventId: string | undefined = hint && hint.event_id;
 
     const promisedEvent = isPrimitive(message)
-      ? this._getBackend().eventFromMessage(`${message}`, level, hint)
+      ? this._getBackend().eventFromMessage(String(message), level, hint)
       : this._getBackend().eventFromException(message, hint);
 
     this._process(

packages/utils/src/is.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+import { Primitive } from '@sentry/types';
 /**
  * Checks whether given value's type is one of a few Error or Error-like
  * {@link isError}.
@@ -65,13 +67,13 @@ export function isString(wat: any): boolean {
 }
 
 /**
- * Checks whether given value's is a primitive (undefined, null, number, boolean, string)
+ * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)
  * {@link isPrimitive}.
  *
  * @param wat A value to be checked.
  * @returns A boolean representing the result.
  */
-export function isPrimitive(wat: any): boolean {
+export function isPrimitive(wat: any): wat is Primitive {
   return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');
 }
 

packages/utils/src/object.ts

@@ -170,7 +170,13 @@ export function normalizeToSize<T>(
   return serialized as T;
 }
 
-/** Transforms any input value into a string form, either primitive value or a type of the input */
+/**
+ * Transform any non-primitive or Symbol-type value into a string. Acts as a no-op on non-Symbol primitives.
+ *
+ * @param value The value to stringify
+ * @returns For non-primitive and Symbol-type values, a string denoting the value's type, or in the case of a Symbol,
+ * its type and description. For non-Symbol primitives, the original value, unchanged.
+ */
 function serializeValue(value: any): any {
   const type = Object.prototype.toString.call(value);
 
@@ -236,6 +242,10 @@ function normalizeValue<T>(value: T, key?: any): T | string {
     return `[Function: ${getFunctionName(value)}]`;
   }
 
+  if (typeof value === 'symbol') {
+    return `[${String(value)}]`;
+  }
+
   return value;
 }