make generic across all javascript

Author: timfish

packages/browser/src/backend.ts

@@ -1,6 +1,6 @@
 import { BaseBackend, getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails } from '@sentry/core';
 import { Event, EventHint, Options, Severity, Transport, TransportOptions } from '@sentry/types';
-import { StackLineParser, StackParser, stackParserFromOptions, supportsFetch } from '@sentry/utils';
+import { stackParserFromOptions, supportsFetch } from '@sentry/utils';
 
 import { eventFromException, eventFromMessage } from './eventbuilder';
 import { FetchTransport, makeNewFetchTransport, makeNewXHRTransport, XHRTransport } from './transports';
@@ -23,12 +23,6 @@ export interface BrowserOptions extends Options {
    * By default, all errors will be sent.
    */
   denyUrls?: Array<string | RegExp>;
-
-  /**
-   * A stack parser implementation or an array of stack line parsers
-   * By default, a stack parser is supplied for all supported browsers
-   */
-  stackParser?: StackParser | StackLineParser[];
 }
 
 /**

packages/node/src/backend.ts

@@ -1,6 +1,6 @@
 import { BaseBackend, getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails } from '@sentry/core';
 import { Event, EventHint, Severity, Transport, TransportOptions } from '@sentry/types';
-import { makeDsn, resolvedSyncPromise } from '@sentry/utils';
+import { makeDsn, resolvedSyncPromise, stackParserFromOptions } from '@sentry/utils';
 
 import { eventFromMessage, eventFromUnknownInput } from './eventbuilder';
 import { HTTPSTransport, HTTPTransport, makeNodeTransport } from './transports';
@@ -16,14 +16,16 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   public eventFromException(exception: any, hint?: EventHint): PromiseLike<Event> {
-    return resolvedSyncPromise(eventFromUnknownInput(exception, hint));
+    return resolvedSyncPromise(eventFromUnknownInput(stackParserFromOptions(this._options), exception, hint));
   }
 
   /**
    * @inheritDoc
    */
   public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {
-    return resolvedSyncPromise(eventFromMessage(message, level, hint, this._options.attachStacktrace));
+    return resolvedSyncPromise(
+      eventFromMessage(stackParserFromOptions(this._options), message, level, hint, this._options.attachStacktrace),
+    );
   }
 
   /**

packages/node/src/eventbuilder.ts

@@ -1,34 +1,31 @@
 import { getCurrentHub } from '@sentry/hub';
-import { Event, EventHint, Exception, Mechanism, Severity, StackFrame } from '@sentry/types';
+import { Event, EventHint, Exception, Mechanism, Severity, StackFrame, StackParser } from '@sentry/types';
 import {
   addExceptionMechanism,
   addExceptionTypeValue,
-  createStackParser,
   extractExceptionKeysForMessage,
   isError,
   isPlainObject,
   normalizeToSize,
 } from '@sentry/utils';
 
-import { nodeStackParser } from './stack-parser';
-
 /**
  * Extracts stack frames from the error.stack string
  */
-export function parseStackFrames(error: Error): StackFrame[] {
-  return createStackParser(nodeStackParser)(error.stack || '', 1);
+export function parseStackFrames(stackParser: StackParser, error: Error): StackFrame[] {
+  return stackParser(error.stack || '', 1);
 }
 
 /**
  * Extracts stack frames from the error and builds a Sentry Exception
  */
-export function exceptionFromError(error: Error): Exception {
+export function exceptionFromError(stackParser: StackParser, error: Error): Exception {
   const exception: Exception = {
     type: error.name || error.constructor.name,
     value: error.message,
   };
 
-  const frames = parseStackFrames(error);
+  const frames = parseStackFrames(stackParser, error);
   if (frames.length) {
     exception.stacktrace = { frames };
   }
@@ -40,7 +37,7 @@ export function exceptionFromError(error: Error): Exception {
  * Builds and Event from a Exception
  * @hidden
  */
-export function eventFromUnknownInput(exception: unknown, hint?: EventHint): Event {
+export function eventFromUnknownInput(stackParser: StackParser, exception: unknown, hint?: EventHint): Event {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let ex: unknown = exception;
   const providedMechanism: Mechanism | undefined =
@@ -73,7 +70,7 @@ export function eventFromUnknownInput(exception: unknown, hint?: EventHint): Eve
 
   const event = {
     exception: {
-      values: [exceptionFromError(ex as Error)],
+      values: [exceptionFromError(stackParser, ex as Error)],
     },
   };
 
@@ -91,6 +88,7 @@ export function eventFromUnknownInput(exception: unknown, hint?: EventHint): Eve
  * @hidden
  */
 export function eventFromMessage(
+  stackParser: StackParser,
   message: string,
   level: Severity = Severity.Info,
   hint?: EventHint,
@@ -103,7 +101,7 @@ export function eventFromMessage(
   };
 
   if (attachStacktrace && hint && hint.syntheticException) {
-    const frames = parseStackFrames(hint.syntheticException);
+    const frames = parseStackFrames(stackParser, hint.syntheticException);
     if (frames.length) {
       event.stacktrace = { frames };
     }

packages/node/src/integrations/linkederrors.ts

@@ -1,7 +1,8 @@
 import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import { Event, EventHint, Exception, ExtendedError, Integration } from '@sentry/types';
-import { isInstanceOf, resolvedSyncPromise, SyncPromise } from '@sentry/utils';
+import { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';
+import { isInstanceOf, resolvedSyncPromise, stackParserFromOptions, SyncPromise } from '@sentry/utils';
 
+import { NodeClient } from '../client';
 import { exceptionFromError } from '../eventbuilder';
 import { ContextLines } from './contextlines';
 
@@ -42,26 +43,29 @@ export class LinkedErrors implements Integration {
    * @inheritDoc
    */
   public setupOnce(): void {
-    addGlobalEventProcessor((event: Event, hint?: EventHint) => {
-      const self = getCurrentHub().getIntegration(LinkedErrors);
+    addGlobalEventProcessor(async (event: Event, hint?: EventHint) => {
+      const hub = getCurrentHub();
+      const self = hub.getIntegration(LinkedErrors);
+      const stackParser = stackParserFromOptions(hub.getClient<NodeClient>()?.getOptions());
+
       if (self) {
-        const handler = self._handler && self._handler.bind(self);
-        return typeof handler === 'function' ? handler(event, hint) : event;
+        await self._handler(stackParser, event, hint);
       }
+
       return event;
     });
   }
 
   /**
    * @inheritDoc
    */
-  private _handler(event: Event, hint?: EventHint): PromiseLike<Event> {
+  private _handler(stackParser: StackParser, event: Event, hint?: EventHint): PromiseLike<Event> {
     if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
       return resolvedSyncPromise(event);
     }
 
     return new SyncPromise<Event>(resolve => {
-      void this._walkErrorTree(hint.originalException as Error, this._key)
+      void this._walkErrorTree(stackParser, hint.originalException as Error, this._key)
         .then((linkedErrors: Exception[]) => {
           if (event && event.exception && event.exception.values) {
             event.exception.values = [...linkedErrors, ...event.exception.values];
@@ -77,12 +81,17 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  private async _walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Promise<Exception[]> {
+  private async _walkErrorTree(
+    stackParser: StackParser,
+    error: ExtendedError,
+    key: string,
+    stack: Exception[] = [],
+  ): Promise<Exception[]> {
     if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
       return Promise.resolve(stack);
     }
 
-    const exception = exceptionFromError(error[key]);
+    const exception = exceptionFromError(stackParser, error[key]);
 
     // If the ContextLines integration is enabled, we add source code context to linked errors
     // because we can't guarantee the order that integrations are run.
@@ -92,7 +101,7 @@ export class LinkedErrors implements Integration {
     }
 
     return new Promise<Exception[]>((resolve, reject) => {
-      void this._walkErrorTree(error[key], key, [exception, ...stack])
+      void this._walkErrorTree(stackParser, error[key], key, [exception, ...stack])
         .then(resolve)
         .then(null, () => {
           reject();

packages/node/src/sdk.ts

@@ -7,6 +7,7 @@ import * as domain from 'domain';
 import { NodeClient } from './client';
 import { IS_DEBUG_BUILD } from './flags';
 import { Console, ContextLines, Http, LinkedErrors, OnUncaughtException, OnUnhandledRejection } from './integrations';
+import { nodeStackParser } from './stack-parser';
 import { NodeOptions } from './types';
 
 export const defaultIntegrations = [
@@ -120,6 +121,10 @@ export function init(options: NodeOptions = {}): void {
     options.autoSessionTracking = true;
   }
 
+  if (options.stackParser === undefined) {
+    options.stackParser = [nodeStackParser];
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
   if ((domain as any).active) {
     setHubOnCarrier(carrier, getCurrentHub());

packages/node/src/stack-parser.ts

@@ -1,4 +1,5 @@
-import { basename, dirname, StackLineParser, StackLineParserFn } from '@sentry/utils';
+import { StackLineParser, StackLineParserFn } from '@sentry/types';
+import { basename, dirname } from '@sentry/utils';
 
 /** Gets the module */
 function getModule(filename: string | undefined): string | undefined {

packages/node/test/context-lines.test.ts

@@ -1,10 +1,14 @@
 import { StackFrame } from '@sentry/types';
+import { createStackParser } from '@sentry/utils';
 import * as fs from 'fs';
 
 import { parseStackFrames } from '../src/eventbuilder';
 import { ContextLines, resetFileContentCache } from '../src/integrations/contextlines';
+import { nodeStackParser } from '../src/stack-parser';
 import { getError } from './helper/error';
 
+const parser = createStackParser(nodeStackParser);
+
 describe('ContextLines', () => {
   let readFileSpy: jest.SpyInstance;
   let contextLines: ContextLines;
@@ -27,7 +31,7 @@ describe('ContextLines', () => {
     test('parseStack with same file', async () => {
       expect.assertions(1);
 
-      const frames = parseStackFrames(new Error('test'));
+      const frames = parseStackFrames(parser, new Error('test'));
 
       await addContext(Array.from(frames));
 
@@ -57,12 +61,12 @@ describe('ContextLines', () => {
 
     test('parseStack with adding different file', async () => {
       expect.assertions(1);
-      const frames = parseStackFrames(new Error('test'));
+      const frames = parseStackFrames(parser, new Error('test'));
 
       await addContext(frames);
 
       const numCalls = readFileSpy.mock.calls.length;
-      const parsedFrames = parseStackFrames(getError());
+      const parsedFrames = parseStackFrames(parser, getError());
       await addContext(parsedFrames);
 
       const newErrorCalls = readFileSpy.mock.calls.length;
@@ -100,7 +104,7 @@ describe('ContextLines', () => {
       contextLines = new ContextLines({ frameContextLines: 0 });
 
       expect.assertions(1);
-      const frames = parseStackFrames(new Error('test'));
+      const frames = parseStackFrames(parser, new Error('test'));
 
       await addContext(frames);
       expect(readFileSpy).toHaveBeenCalledTimes(0);

packages/node/test/index.test.ts

@@ -1,6 +1,7 @@
 import { initAndBind, SDK_VERSION } from '@sentry/core';
 import { getMainCarrier } from '@sentry/hub';
 import { Integration } from '@sentry/types';
+import { createStackParser } from '@sentry/utils';
 import * as domain from 'domain';
 
 import {
@@ -17,6 +18,9 @@ import {
 } from '../src';
 import { NodeBackend } from '../src/backend';
 import { ContextLines, LinkedErrors } from '../src/integrations';
+import { nodeStackParser } from '../src/stack-parser';
+
+const stackParser = createStackParser(nodeStackParser);
 
 jest.mock('@sentry/core', () => {
   const original = jest.requireActual('@sentry/core');
@@ -87,6 +91,7 @@ describe('SentryNode', () => {
 
     test('record auto breadcrumbs', done => {
       const client = new NodeClient({
+        stackParser,
         beforeSend: (event: Event) => {
           // TODO: It should be 3, but we don't capture a breadcrumb
           // for our own captureMessage/captureException calls yet
@@ -118,6 +123,7 @@ describe('SentryNode', () => {
       expect.assertions(6);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(event.tags).toEqual({ test: '1' });
             expect(event.exception).not.toBeUndefined();
@@ -145,6 +151,7 @@ describe('SentryNode', () => {
       expect.assertions(6);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(event.tags).toEqual({ test: '1' });
             expect(event.exception).not.toBeUndefined();
@@ -172,6 +179,7 @@ describe('SentryNode', () => {
       expect.assertions(10);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(event.tags).toEqual({ test: '1' });
             expect(event.exception).not.toBeUndefined();
@@ -203,6 +211,7 @@ describe('SentryNode', () => {
       expect.assertions(15);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           integrations: [new ContextLines(), new LinkedErrors()],
           beforeSend: (event: Event) => {
             expect(event.exception).not.toBeUndefined();
@@ -243,6 +252,7 @@ describe('SentryNode', () => {
       expect.assertions(2);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(event.message).toBe('test');
             expect(event.exception).toBeUndefined();
@@ -259,6 +269,7 @@ describe('SentryNode', () => {
       expect.assertions(2);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(event.message).toBe('test event');
             expect(event.exception).toBeUndefined();
@@ -275,6 +286,7 @@ describe('SentryNode', () => {
       const d = domain.create();
 
       const client = new NodeClient({
+        stackParser,
         beforeSend: (event: Event) => {
           expect(event.message).toBe('test domain');
           expect(event.exception).toBeUndefined();
@@ -295,6 +307,7 @@ describe('SentryNode', () => {
       expect.assertions(1);
       getCurrentHub().bindClient(
         new NodeClient({
+          stackParser,
           beforeSend: (event: Event) => {
             expect(
               event.exception!.values![0].stacktrace!.frames![