node: Use syntheticException in the same was as we do in the browser

Author: kamilogorek

packages/browser/src/parsers.ts

@@ -58,9 +58,10 @@ export function prepareFramesForEvent(stack: TraceKitStackFrame[]): StackFrame[]
   }
 
   let localStack = stack;
+  const firstFrameFunction = localStack[0].func || '';
 
   // TODO: This could be smarter
-  if (localStack[0].func.includes('captureMessage') || localStack[0].func.includes('captureException')) {
+  if (firstFrameFunction.includes('captureMessage') || firstFrameFunction.includes('captureException')) {
     localStack = localStack.slice(1);
   }
 

packages/node/src/backend.ts

@@ -4,8 +4,7 @@ import { SentryEvent, SentryResponse } from '@sentry/types';
 import { isError, isPlainObject } from '@sentry/utils/is';
 import { limitObjectDepthToSize, serializeKeysToEventMessage } from '@sentry/utils/object';
 import * as md5 from 'md5';
-import * as stacktrace from 'stack-trace';
-import { parseError, parseStack, prepareFramesForEvent } from './parsers';
+import { extractStackFromError, parseError, parseStack, prepareFramesForEvent } from './parsers';
 import { HTTPSTransport, HTTPTransport } from './transports';
 
 /**
@@ -26,8 +25,7 @@ export class NodeBackend implements Backend {
    * @inheritDoc
    */
   public async eventFromException(exception: any, syntheticException: Error | null): Promise<SentryEvent> {
-    let stack: stacktrace.StackFrame[] | undefined;
-    let ex: any = exception;
+    let ex: Error = exception;
 
     if (!isError(exception)) {
       if (isPlainObject(exception)) {
@@ -42,18 +40,16 @@ export class NodeBackend implements Backend {
           scope.setFingerprint([md5(keys.join(''))]);
         });
 
-        // TODO: Use syntheticException here as well
-        ex = new Error(message);
+        ex = syntheticException || new Error(message);
+        ex.message = message;
       } else {
         // This handles when someone does: `throw "something awesome";`
         // We use synthesized Error here so we can extract a (rough) stack trace.
         ex = syntheticException || new Error(exception as string);
       }
-
-      stack = stacktrace.get();
     }
 
-    const event: SentryEvent = stack ? await parseError(ex as Error, stack) : await parseError(ex as Error);
+    const event: SentryEvent = await parseError(ex);
 
     return event;
   }
@@ -62,13 +58,9 @@ export class NodeBackend implements Backend {
    * @inheritDoc
    */
   public async eventFromMessage(message: string, syntheticException: Error | null): Promise<SentryEvent> {
-    // TODO: Use syntheticException to get a stack
-    const stack = stacktrace.get();
+    const stack = syntheticException ? await extractStackFromError(syntheticException) : [];
     const frames = await parseStack(stack);
     const event: SentryEvent = {
-      extra: {
-        TODOmakeLinterHappyAKARemoveIt: syntheticException,
-      },
       message,
       stacktrace: {
         frames: prepareFramesForEvent(frames),

packages/node/src/parsers.ts

@@ -101,8 +101,7 @@ async function readSourceFiles(
  */
 export async function extractStackFromError(error: Error): Promise<stacktrace.StackFrame[]> {
   const stack = stacktrace.parse(error);
-  if (!stack || !Array.isArray(stack) || !stack.length || !stack[0].getFileName) {
-    // the stack is not the useful thing we were expecting :/
+  if (!stack) {
     return [];
   }
   return stack;
@@ -174,9 +173,9 @@ export async function parseStack(stack: stacktrace.StackFrame[]): Promise<StackF
 /**
  * TODO
  */
-export async function parseError(error: ExtendedError, ownStack?: stacktrace.StackFrame[]): Promise<SentryEvent> {
+export async function parseError(error: ExtendedError): Promise<SentryEvent> {
   const name = error.name || error.constructor.name;
-  const stack = ownStack || (await extractStackFromError(error));
+  const stack = await extractStackFromError(error);
   const frames = await parseStack(stack);
   const event: SentryEvent = {
     exception: {
@@ -220,29 +219,20 @@ export async function parseError(error: ExtendedError, ownStack?: stacktrace.Sta
 /**
  * TODO
  */
-export function prepareFramesForEvent(frames: StackFrame[]): StackFrame[] {
-  let filteredFrames: StackFrame[] = frames;
-
-  // Remove frames that don't have filename, colno and lineno.
-  // Things like `new Promise` called by generated code
-  // eg. async/await from regenerator
-  filteredFrames = filteredFrames.filter(frame => !(!frame.filename && !frame.colno && !frame.lineno));
-
-  // TODO: REMOVE ME, TESTING ONLY
-  for (const frame of filteredFrames) {
-    if (frame.filename && frame.filename.includes('/dist/')) {
-      frame.in_app = false;
-    }
+export function prepareFramesForEvent(stack: StackFrame[]): StackFrame[] {
+  if (!stack) {
+    return [];
   }
 
-  const firstInAppFrameIndex = filteredFrames.findIndex(frame => frame.in_app === true);
+  let localStack = stack;
+  const firstFrameFunction = localStack[0].function || '';
 
-  // Remove every frame that happened after our first in_app call
-  // which basically means all the internal async stuff
-  if (firstInAppFrameIndex !== -1) {
-    filteredFrames = filteredFrames.slice(firstInAppFrameIndex);
+  // TODO: This could be smarter
+  if (firstFrameFunction.includes('captureMessage') || firstFrameFunction.includes('captureException')) {
+    localStack = localStack.slice(1);
   }
 
+  return localStack;
   // Sentry expects the stack trace to be oldest -> newest, v8 provides newest -> oldest
-  return filteredFrames.reverse();
+  // return filteredFrames.reverse();
 }