parse stack moved to sdk from worker, using asynchronously fethcing context from internal files with fs

Author: piotrek98

package.json

@@ -1,6 +1,6 @@
 {
   "name": "klepper",
-  "version": "0.0.47-alpha",
+  "version": "0.0.60-alpha",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/http.ts

@@ -44,9 +44,7 @@ const createHttpOptions = ({
 const statusFromCode = (code: number) =>
   code >= 200 && code <= 299 ? RequestStatus.SUCCESS : RequestStatus.ERROR;
 
-export const sendConnection = (
-  connectionData: KlepperReleaseEvent
-): void => {
+export const sendConnection = (connectionData: KlepperReleaseEvent): void => {
   const httpOptions = createHttpOptions({
     event: connectionData,
     api: "/sdk/release",

src/node/middlewares.ts

@@ -1,8 +1,6 @@
-import { getGlobalClientData } from "../core/global";
 import { sendEvent } from "../core/http";
 import { isClientConnected, isLocalhost } from "../core/is";
 import { KlepperError } from "../transport/base";
-import { CatchType } from "../transport/enums";
 import { KlepperEvent } from "../transport/events";
 import {
   KlepperIncomingMessage,
@@ -12,7 +10,8 @@ import {
   CatchExceptionsOptions,
   ErrorMiddlewareOptions,
 } from "../transport/options";
-import { getIp, getProtocol, mapRequestData } from "./helpers";
+import { getIp, getProtocol } from "./helpers";
+import { prepareException } from "./parse";
 
 /**
  * Base middleware to catch and intercept error across the express app.
@@ -38,19 +37,19 @@ import { getIp, getProtocol, mapRequestData } from "./helpers";
  *
  */
 const errorMiddleware = (options: ErrorMiddlewareOptions = {}) => {
-  return function errorMiddleware(
+  return async function errorMiddleware(
     error: KlepperError,
     req: KlepperIncomingMessage,
     _res: KlepperServerResponse,
     next: (error: KlepperError) => void
-  ): void {
+  ): Promise<void> {
     if (!isClientConnected()) {
       next(error);
       return;
     }
 
     if (isToCatch(req, options)) {
-      handleException(error, req);
+      await handleException(error, req);
     }
 
     next(error);
@@ -125,22 +124,12 @@ const handleException = async (
   req?: KlepperIncomingMessage,
   options?: CatchExceptionsOptions
 ) => {
-  const { message, name } = error;
-
-  const event: KlepperEvent = {
-    date: Date.now(),
-    type: name,
-    message,
-    stack: error.stack as string,
-    catchType: req ? CatchType.MIDDLEWARE : CatchType.INTERNAL,
-    options,
-  };
-
-  if (req !== undefined) {
-    event.requestData = mapRequestData(req);
+  try {
+    const event: KlepperEvent = await prepareException(error, options, req);
+    await sendEvent(event);
+  } catch (err) {
+    //
   }
-
-  await sendEvent(event);
 };
 
 export const Middleware = {

src/node/parse.ts

@@ -0,0 +1,143 @@
+import { Trace } from "../transport/trace";
+import { promises, existsSync } from "fs";
+import { KlepperError } from "../transport/base";
+import { CatchExceptionsOptions, KlepperOptions } from "../transport/options";
+import { KlepperEvent } from "../transport/events";
+import { KlepperIncomingMessage } from "../transport/http";
+import { mapRequestData } from "./helpers";
+
+const FULL_MATCH =
+    /at (?:async )?(?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/;
+
+export const parseStackTraces = async (stack: string): Promise<Trace[]> => {
+    const frames: Trace[] = [];
+
+    if (!stack.length) {
+        return [];
+    }
+
+    for (const line of stack.split("\n").slice(1)) {
+        const frame = await createTrace(line);
+        if (frame) {
+            frames.push(frame);
+        }
+    }
+
+    return (
+        frames.slice(0, 25).map((frame) => ({
+            ...frame,
+        })) || []
+    );
+};
+
+export const createTrace = async (line: string): Promise<Trace | undefined> => {
+    const lineMatch = line.match(FULL_MATCH);
+    if (!lineMatch || lineMatch[0].includes("<anonymous>")) {
+        return undefined;
+    }
+
+    let functionName: string | undefined;
+    let typeName: string | undefined;
+    let methodName: string | undefined;
+    let splitedPath: string[] | undefined;
+
+    if (lineMatch[1]) {
+        functionName = lineMatch[1];
+    }
+
+    if (functionName === undefined) {
+        functionName = typeName ? `${typeName}.${methodName}` : "<anonymous>";
+    }
+
+    const path = lineMatch[2]?.startsWith("file://")
+        ? lineMatch[2].substr(7)
+        : lineMatch[2];
+    const internal =
+        path !== undefined &&
+        !path.includes("node_modules/") &&
+        !path.includes("node_modules\\") &&
+        !path.includes("internal/");
+
+    const isNodeProcess = path?.includes("internal") || path?.includes("process");
+    isNodeProcess
+        ? (splitedPath = path?.split("/"))
+        : (splitedPath = path?.split("\\"));
+
+    const fileName = splitedPath[splitedPath?.length - 1];
+
+    const splitedFilename = fileName.split(".");
+    const extension = splitedFilename[splitedFilename.length - 1];
+    const lineNo = parseInt(lineMatch[3], 10);
+
+    const { code, preCode, postCode } = await getCodeFromFs(path, lineNo);
+
+    return {
+        filename: fileName,
+        function: functionName,
+        absPath: path,
+        lineNo,
+        columnNo: parseInt(lineMatch[4], 10) || undefined,
+        internal,
+        extension,
+        code,
+        postCode,
+        preCode,
+    };
+};
+
+const getCodeFromFs = async (
+    path: string,
+    codeLine: number
+): Promise<{ code: string; preCode: string[]; postCode: string[] }> => {
+    let code: string = "";
+    let preCode: string[] = [];
+    let postCode: string[] = [];
+    let linesOfCode: string[] = [];
+
+    const context = await readFileAsync(path);
+
+    if (context) {
+        linesOfCode = context?.split("\n");
+
+        code = linesOfCode[codeLine - 1];
+        preCode = linesOfCode.slice(codeLine - 6, codeLine - 1);
+        postCode = linesOfCode.slice(codeLine + 1, codeLine + 6);
+    }
+
+    return {
+        code,
+        preCode,
+        postCode,
+    };
+};
+
+const readFileAsync = async (path: string): Promise<string> => {
+    let context = "";
+
+    //check if file with this path exist
+    const isFileExists = existsSync(path);
+    if (isFileExists) {
+        context = await promises.readFile(path, "utf8");
+    }
+
+    return context;
+};
+
+export const prepareException = async (error: KlepperError, options?: CatchExceptionsOptions, req?: KlepperIncomingMessage): Promise<KlepperEvent> => {
+    const { message, name } = error;
+
+    const traces = await parseStackTraces(String(error?.stack));
+    const event: KlepperEvent = {
+        type: name,
+        message,
+        traces,
+        stack: String(error.stack),
+        options
+    };
+
+    if (req !== undefined) {
+        event.requestData = mapRequestData(req);
+    }
+
+    return event;
+}

src/node/sdk.ts

@@ -54,11 +54,11 @@ export const init = (
     env: options?.environment,
     version: options?.version,
     os: {
-      arch: os.arch(),    
+      arch: os.arch(),
       platform: os.platform(),
       release: os.release(),
       version: os.version(),
-    }
+    },
   };
 
   sendConnection(conn);

src/transport/events.ts

@@ -1,5 +1,6 @@
 import { CatchType, ExceptionPriority } from "./enums";
 import { KlepperRequest } from "./http";
+import { Trace } from "./trace";
 import { Environment } from "./types";
 
 export interface EventResponse {
@@ -25,8 +26,8 @@ export interface KlepperEvent {
   projectId?: string;
   type: string;
   message: string;
-  date: number;
   stack: string;
+  traces: Trace[];
   requestData?: KlepperRequest;
   catchType?: CatchType;
   options?: {
@@ -42,9 +43,9 @@ export interface KlepperReleaseEvent {
   version?: string;
   env: Environment;
   os: {
-    arch: string,    
-    platform: string,
-    release: string,
-    version: string,
-  }
+    arch: string;
+    platform: string;
+    release: string;
+    version: string;
+  };
 }

src/transport/trace.ts

@@ -0,0 +1,12 @@
+export interface Trace {
+  filename?: string;
+  function?: string;
+  lineNo?: number;
+  columnNo?: number;
+  internal?: boolean;
+  absPath?: string;
+  extension?: string;
+  preCode?: string[];
+  code?: string;
+  postCode?: string[];
+}