Ajout de la gestion de l'ID de requête et de la pile d'erreurs dans les réponses des fonctions

Author: amrltqt

src/main.ts

@@ -29,6 +29,7 @@ type WorkerResponse = {
     body: string;
   };
   error?: string;
+  errorStack?: string;
 };
 
 const timeoutMs = Number(Deno.env.get("RUNHOOK_TIMEOUT_MS") ?? "1500");
@@ -166,15 +167,28 @@ async function handleWebhook(req: Request, url: URL, path: string): Promise<Resp
     now: new Date().toISOString(),
   };
 
+  const requestId = crypto.randomUUID();
+
   try {
-    const response = await runFunction(func.code, ctx);
+    const response = await runFunction(func.code, ctx, requestId);
+    const headers = new Headers(response.headers);
+    headers.set("x-runhook-request-id", requestId);
     return new Response(response.body, {
       status: response.status,
-      headers: response.headers,
+      headers,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return jsonResponse({ error: message }, 500);
+    const stack = err instanceof Error ? err.stack : undefined;
+    console.error("function execution failed", {
+      requestId,
+      name,
+      error: message,
+      stack,
+    });
+    const resp = jsonResponse({ error: message, requestId }, 500);
+    resp.headers.set("x-runhook-request-id", requestId);
+    return resp;
   }
 }
 
@@ -193,7 +207,7 @@ function handleMcp(req: Request, path: string): Response | Promise<Response> {
   return jsonResponse({ error: "not found" }, 404);
 }
 
-async function runFunction(code: string, ctx: ExecContext): Promise<{
+async function runFunction(code: string, ctx: ExecContext, requestId: string): Promise<{
   status: number;
   headers: Record<string, string>;
   body: string;
@@ -212,15 +226,14 @@ async function runFunction(code: string, ctx: ExecContext): Promise<{
     },
   });
 
-  const id = crypto.randomUUID();
   const result = await new Promise<WorkerResponse>((resolve, reject) => {
     const timer = setTimeout(() => {
       worker.terminate();
       reject(new Error("execution timeout"));
     }, timeoutMs);
 
     worker.onmessage = (event: MessageEvent<WorkerResponse>) => {
-      if (event.data?.id !== id) return;
+      if (event.data?.id !== requestId) return;
       clearTimeout(timer);
       resolve(event.data);
     };
@@ -230,12 +243,18 @@ async function runFunction(code: string, ctx: ExecContext): Promise<{
       reject(new Error(event.message));
     };
 
-    worker.postMessage({ id, code, ctx });
+    worker.postMessage({ id: requestId, code, ctx });
   });
 
   worker.terminate();
 
-  if (!result.ok) throw new Error(result.error || "execution error");
+  if (!result.ok) {
+    const err = new Error(result.error || "execution error");
+    if (result.errorStack) {
+      err.stack = result.errorStack;
+    }
+    throw err;
+  }
   if (!result.response) throw new Error("empty response");
   return result.response;
 }

src/worker.ts

@@ -13,6 +13,7 @@ type WorkerResponse = {
     body: string;
   };
   error?: string;
+  errorStack?: string;
 };
 
 self.onmessage = async (event: MessageEvent<WorkerRequest>) => {
@@ -35,7 +36,8 @@ self.onmessage = async (event: MessageEvent<WorkerRequest>) => {
     self.postMessage(message);
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    const message: WorkerResponse = { id, ok: false, error };
+    const errorStack = err instanceof Error ? err.stack : undefined;
+    const message: WorkerResponse = { id, ok: false, error, errorStack };
     self.postMessage(message);
   }
 };