Merge pull request #738 from rage/errorlog

Improved error messages & logging

Author: nygrenh

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [3.1.1] - 2025-02-21
+
+-   Improved error messages and logging.
+
 ## [3.1.0] - 2024-12-17
 
 -   Fixed downloading old submissions for C# exercises

backend/tsconfig.json

@@ -2,6 +2,6 @@
     "compilerOptions": {
         "esModuleInterop": true,
         "module": "commonjs",
-        "target": "ES6"
+        "target": "ES2022"
     }
 }

bin/validateRelease.sh

@@ -18,10 +18,10 @@ then
 fi
 
 # Make sure that the package-lock.json version also matches
-packageLockVersion=$(grep -Eo '"version":.+$' package-lock.json)
+packageLockVersion=$(grep -Eom 1 '"version":.+$' package-lock.json)
 if [[ ! $packageLockVersion =~ '"version": "'$tagVersion'",' ]]
 then
-    echo "Error: The version in package-lock.json '${packageVersion}' doesn't match with the tag '${tagVersion}'. Run 'npm i --package-lock-only'}"
+    echo "Error: The version in package-lock.json '${packageLockVersion}' doesn't match with the tag '${tagVersion}'. Run \`npm i --package-lock-only\`."
     exitCode=1
 fi
 

package-lock.json

@@ -1,7 +1,7 @@
 {
     "name": "test-my-code",
     "displayName": "TestMyCode",
-    "version": "3.1.0",
+    "version": "3.1.1",
     "description": "TestMyCode extension for Visual Studio Code",
     "categories": [
         "Education",

package.json

@@ -2,8 +2,8 @@
     "compilerOptions": {
         "noEmit": true,
         "module": "commonjs",
-        "target": "es6",
-        "lib": ["es6"],
+        "target": "ES2022",
+        "lib": ["ES2022"],
         "sourceMap": true,
         "rootDir": ".",
         "strict": true

playwright/tsconfig.json

@@ -3,8 +3,10 @@
  */
 
 import { Uri } from "vscode";
+import * as util from "node:util";
 
 import { Course, Organization, RunResult, SubmissionFinished } from "./langsSchema";
+import { createIs } from "typia";
 
 /**
  * Contains the state of the webview.
@@ -529,9 +531,105 @@ export function assertUnreachable(x: never): never {
  */
 export class BaseError extends Error {
     public readonly name: string = "Base Error";
-    public details: string;
-    constructor(message?: string, details?: string) {
+    public details?: string;
+    public cause?: NodeJS.ErrnoException | string;
+    public stack?: string;
+
+    // possible fields from ErrnoException
+    public errno?: number;
+    public code?: string;
+    public path?: string;
+    public syscall?: string;
+
+    constructor(err: unknown);
+    constructor(err: Error, details?: string);
+    constructor(message?: string, details?: string);
+
+    constructor(err: unknown, details?: string) {
+        let message = "";
+        let stack = "";
+        let cause: NodeJS.ErrnoException | string = "";
+
+        let errno: number | undefined = undefined;
+        let code: string | undefined = undefined;
+        let path: string | undefined = undefined;
+        let syscall: string | undefined = undefined;
+
+        // simple check first...
+        if (typeof err === "string") {
+            message = err;
+        } else if (util.types.isNativeError(err)) {
+            // deal with regular error stuff first
+            message = err.message;
+            if (err.stack) {
+                stack = err.stack;
+            }
+
+            // also check for special NodeJS error
+            if (createIs<NodeJS.ErrnoException>()(err)) {
+                // nodejs error with error code
+                errno = err.errno;
+                code = err.code;
+                path = err.path;
+                syscall = err.syscall;
+            }
+
+            if (err.cause) {
+                // same checks for cause
+                if (
+                    util.types.isNativeError(err.cause) &&
+                    createIs<NodeJS.ErrnoException>()(err.cause)
+                ) {
+                    cause = err.cause;
+                } else {
+                    cause = err.cause.toString();
+                }
+            }
+        } else {
+            // it's expected that this function is only called with
+            // strings or error objects. but since errors are often "unknown"
+            // in catch statements etc., this function accepts unknown types
+            // and thus we'll handle them here just in case
+            message = `Unexpected error ${err} (${typeof err})`;
+        }
+
         super(message);
-        this.details = details ?? "";
+        this.details = details;
+        if (stack) {
+            this.stack = stack;
+        }
+        if (cause) {
+            this.cause = cause;
+        }
+
+        // errno fields
+        this.errno = errno;
+        this.code = code;
+        this.path = path;
+        this.syscall = syscall;
+    }
+
+    public toString(): string {
+        let errorMessage = "";
+        if (this.errno) {
+            errorMessage += `[${this.errno}] `;
+        }
+        if (this.code) {
+            errorMessage += `(${this.code}) `;
+        }
+        if (this.syscall) {
+            errorMessage += `\`${this.syscall}\` `;
+        }
+        if (this.path) {
+            errorMessage += `@${this.path} `;
+        }
+        errorMessage += `${this.name}: ${this.message}.`;
+        if (this.details) {
+            errorMessage += ` ${this.details}.`;
+        }
+        if (this.cause) {
+            errorMessage += ` Caused by: ${this.cause}.`;
+        }
+        return errorMessage;
     }
 }

shared/lib.ts

@@ -25,7 +25,7 @@ export async function checkForExerciseUpdates(
 ): Promise<Result<OutdatedExercise[], Error>> {
     const { tmc, userData } = actionContext;
     const forceRefresh = options?.forceRefresh ?? false;
-    Logger.info(`Checking for exercise updates, forced update: ${forceRefresh}`);
+    Logger.info("Checking for exercise updates, forced update:", forceRefresh);
 
     const checkUpdatesResult = await tmc.checkExerciseUpdates({ forceRefresh });
     if (checkUpdatesResult.err) {

src/actions/checkForExerciseUpdates.ts

@@ -19,7 +19,7 @@ export async function downloadNewExercisesForCourse(
 ): Promise<Result<void, Error>> {
     const { userData } = actionContext;
     const course = userData.getCourse(courseId);
-    Logger.info(`Downloading new exercises for course: ${course.title}`);
+    Logger.info("Downloading new exercises for course:", course.title);
 
     const postNewExercises = async (exerciseIds: number[]): Promise<void> =>
         await TmcPanel.postMessage({

src/actions/downloadNewExercisesForCourse.ts

@@ -202,7 +202,7 @@ export async function submitExercise(
 
     if (submissionResult.err) {
         if (submissionResult.val instanceof BottleneckError) {
-            Logger.warn(`Submission was cancelled: ${submissionResult.val.message}.`);
+            Logger.warn("Submission was cancelled:", submissionResult.val);
             return Ok.EMPTY;
         }
         TmcPanel.postMessage({