feat(v8): Update eventFromUnknownInput to only use client (#10692)

ref #10100

Author: AbhiPrasad

packages/core/src/server-runtime-client.ts

@@ -15,7 +15,7 @@ import { eventFromMessage, eventFromUnknownInput, logger, resolvedSyncPromise, u
 
 import { BaseClient } from './baseclient';
 import { createCheckInEnvelope } from './checkin';
-import { getClient, getIsolationScope } from './currentScopes';
+import { getIsolationScope } from './currentScopes';
 import { DEBUG_BUILD } from './debug-build';
 import type { Scope } from './scope';
 import { SessionFlusher } from './sessionflusher';
@@ -56,7 +56,7 @@ export class ServerRuntimeClient<
    * @inheritDoc
    */
   public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
-    return resolvedSyncPromise(eventFromUnknownInput(getClient(), this._options.stackParser, exception, hint));
+    return resolvedSyncPromise(eventFromUnknownInput(this, this._options.stackParser, exception, hint));
   }
 
   /**

packages/deno/src/integrations/globalhandlers.ts

@@ -67,7 +67,7 @@ function installGlobalErrorHandler(client: Client): void {
 
     const { message, error } = data;
 
-    const event = eventFromUnknownInput(getClient(), stackParser, error || message);
+    const event = eventFromUnknownInput(client, stackParser, error || message);
 
     event.level = 'fatal';
 
@@ -116,7 +116,7 @@ function installGlobalUnhandledRejectionHandler(client: Client): void {
 
     const event = isPrimitive(error)
       ? eventFromRejectionWithPrimitive(error)
-      : eventFromUnknownInput(getClient(), stackParser, error, undefined);
+      : eventFromUnknownInput(client, stackParser, error, undefined);
 
     event.level = 'fatal';
 

packages/node/test/eventbuilders.test.ts

@@ -1,4 +1,3 @@
-import type { Hub } from '@sentry/types';
 import { eventFromUnknownInput } from '@sentry/utils';
 
 import { defaultStackParser } from '../src';
@@ -44,50 +43,4 @@ describe('eventFromUnknownInput', () => {
       },
     });
   });
-
-  test('uses normalizeDepth from init options (passing getCurrentHub)', () => {
-    const deepObject = {
-      a: {
-        b: {
-          c: {
-            d: {
-              e: {
-                f: {
-                  g: 'foo',
-                },
-              },
-            },
-          },
-        },
-      },
-    };
-
-    const getCurrentHub = jest.fn(() => {
-      return {
-        getClient: () => ({
-          getOptions(): any {
-            return { normalizeDepth: 6 };
-          },
-        }),
-      } as unknown as Hub;
-    });
-
-    const event = eventFromUnknownInput(getCurrentHub, defaultStackParser, deepObject);
-
-    const serializedObject = event.extra?.__serialized__;
-    expect(serializedObject).toBeDefined();
-    expect(serializedObject).toEqual({
-      a: {
-        b: {
-          c: {
-            d: {
-              e: {
-                f: '[Object]',
-              },
-            },
-          },
-        },
-      },
-    });
-  });
 });

packages/utils/src/eventbuilder.ts

@@ -4,7 +4,6 @@ import type {
   EventHint,
   Exception,
   Extras,
-  Hub,
   Mechanism,
   ParameterizedString,
   SeverityLevel,
@@ -63,22 +62,14 @@ function getMessageForObject(exception: object): string {
 
 /**
  * Builds and Event from a Exception
- *
- * TODO(v8): Remove getHub fallback
  * @hidden
  */
 export function eventFromUnknownInput(
-  getHubOrClient: (() => Hub) | Client | undefined,
+  client: Client,
   stackParser: StackParser,
   exception: unknown,
   hint?: EventHint,
 ): Event {
-  const client =
-    typeof getHubOrClient === 'function'
-      ? // eslint-disable-next-line deprecation/deprecation
-        getHubOrClient().getClient()
-      : getHubOrClient;
-
   let ex: unknown = exception;
   const providedMechanism: Mechanism | undefined =
     hint && hint.data && (hint.data as { mechanism: Mechanism }).mechanism;

packages/utils/test/eventbuilder.test.ts

@@ -1,44 +1,35 @@
-import type { Hub, Scope } from '@sentry/types';
+import type { Client } from '@sentry/types';
 
 import { createStackParser, eventFromUnknownInput, nodeStackLineParser } from '../src';
 
-function getCurrentHub(): Hub {
-  // Some fake hub to get us through
-  return {
-    getClient: () => undefined,
-    getScope: () => {
-      return {
-        setExtra: () => {},
-      } as unknown as Scope;
-    },
-  } as unknown as Hub;
-}
-
 const stackParser = createStackParser(nodeStackLineParser());
 
 describe('eventFromUnknownInput', () => {
+  const fakeClient = {
+    getOptions: () => ({}),
+  } as Client;
   test('object with useless props', () => {
-    const event = eventFromUnknownInput(getCurrentHub, stackParser, { foo: { bar: 'baz' }, prop: 1 });
+    const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, prop: 1 });
     expect(event.exception?.values?.[0].value).toBe('Object captured as exception with keys: foo, prop');
   });
 
   test('object with name prop', () => {
-    const event = eventFromUnknownInput(getCurrentHub, stackParser, { foo: { bar: 'baz' }, name: 'BadType' });
+    const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, name: 'BadType' });
     expect(event.exception?.values?.[0].value).toBe("'BadType' captured as exception");
   });
 
   test('object with name and message props', () => {
-    const event = eventFromUnknownInput(getCurrentHub, stackParser, { message: 'went wrong', name: 'BadType' });
+    const event = eventFromUnknownInput(fakeClient, stackParser, { message: 'went wrong', name: 'BadType' });
     expect(event.exception?.values?.[0].value).toBe("'BadType' captured as exception with message 'went wrong'");
   });
 
   test('object with message prop', () => {
-    const event = eventFromUnknownInput(getCurrentHub, stackParser, { foo: { bar: 'baz' }, message: 'Some message' });
+    const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, message: 'Some message' });
     expect(event.exception?.values?.[0].value).toBe('Some message');
   });
 
   test('passing client directly', () => {
-    const event = eventFromUnknownInput(undefined, stackParser, { foo: { bar: 'baz' }, prop: 1 });
+    const event = eventFromUnknownInput(fakeClient, stackParser, { foo: { bar: 'baz' }, prop: 1 });
     expect(event.exception?.values?.[0].value).toBe('Object captured as exception with keys: foo, prop');
   });
 });