@workglow/job-queue 0.1.1 → 0.2.0

package/dist/bun.js

@@ -6,13 +6,8 @@ import { JobStatus } from "@workglow/storage";
 import { BaseError } from "@workglow/util";
 
 class JobError extends BaseError {
-  message;
   static type = "JobError";
   retryable = false;
-  constructor(message) {
-    super(message);
-    this.message = message;
-  }
 }
 
 class JobNotFoundError extends JobError {
@@ -34,16 +29,10 @@ class RetryableJobError extends JobError {
 
 class PermanentJobError extends JobError {
   static type = "PermanentJobError";
-  constructor(message) {
-    super(message);
-  }
 }
 
 class AbortSignalJobError extends PermanentJobError {
   static type = "AbortSignalJobError";
-  constructor(message) {
-    super(message);
-  }
 }
 
 class JobDisabledError extends PermanentJobError {
@@ -135,6 +124,57 @@ class Job {
   }
 }
 
+// src/job/JobErrorDiagnostics.ts
+var JOB_ERROR_DIAGNOSTICS_MARKER = `
+
+--- Error diagnostics ---
+`;
+var DEFAULT_MAX_DIAGNOSTICS_CHARS = 48000;
+function formatErrorChainForDiagnostics(err, maxChars = DEFAULT_MAX_DIAGNOSTICS_CHARS) {
+  const lines = [];
+  let current = err;
+  for (let depth = 0;depth < 8 && current != null; depth++) {
+    if (current instanceof Error) {
+      lines.push(`${current.name}: ${current.message}`);
+      if (current.stack) {
+        lines.push(current.stack);
+      }
+      const next = current.cause;
+      if (next === undefined || next === null) {
+        break;
+      }
+      lines.push("");
+      current = next;
+    } else {
+      lines.push(typeof current === "string" ? current : String(current));
+      break;
+    }
+  }
+  const text = lines.join(`
+`);
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+\u2026(truncated)`;
+}
+function withJobErrorDiagnostics(summaryLine, err) {
+  const diag = formatErrorChainForDiagnostics(err);
+  if (diag.length === 0) {
+    return summaryLine;
+  }
+  return `${summaryLine}${JOB_ERROR_DIAGNOSTICS_MARKER}${diag}`;
+}
+function applyPersistedDiagnosticsToStack(jobError, fullMessage) {
+  if (!fullMessage.includes(JOB_ERROR_DIAGNOSTICS_MARKER)) {
+    return;
+  }
+  const firstLine = fullMessage.split(`
+`)[0] ?? fullMessage;
+  jobError.stack = `${jobError.name}: ${firstLine}
+${fullMessage}`;
+}
+
 // src/job/JobQueueClient.ts
 import { JobStatus as JobStatus2 } from "@workglow/storage";
 import { EventEmitter } from "@workglow/util";
@@ -465,18 +505,28 @@ class JobQueueClient {
   }
   buildErrorFromCode(message, errorCode) {
     if (errorCode === "PermanentJobError") {
-      return new PermanentJobError(message);
+      const err2 = new PermanentJobError(message);
+      applyPersistedDiagnosticsToStack(err2, message);
+      return err2;
     }
     if (errorCode === "RetryableJobError") {
-      return new RetryableJobError(message);
+      const err2 = new RetryableJobError(message);
+      applyPersistedDiagnosticsToStack(err2, message);
+      return err2;
     }
     if (errorCode === "AbortSignalJobError") {
-      return new AbortSignalJobError(message);
+      const err2 = new AbortSignalJobError(message);
+      applyPersistedDiagnosticsToStack(err2, message);
+      return err2;
     }
     if (errorCode === "JobDisabledError") {
-      return new JobDisabledError(message);
+      const err2 = new JobDisabledError(message);
+      applyPersistedDiagnosticsToStack(err2, message);
+      return err2;
     }
-    return new JobError(message);
+    const err = new JobError(message);
+    applyPersistedDiagnosticsToStack(err, message);
+    return err;
   }
 }
 
@@ -503,7 +553,14 @@ class NullLimiter {
 
 // src/job/JobQueueWorker.ts
 import { JobStatus as JobStatus3 } from "@workglow/storage";
-import { EventEmitter as EventEmitter2, getTelemetryProvider, sleep, SpanStatusCode, uuid4 } from "@workglow/util";
+import {
+  EventEmitter as EventEmitter2,
+  getLogger,
+  getTelemetryProvider,
+  sleep,
+  SpanStatusCode,
+  uuid4
+} from "@workglow/util";
 class JobQueueWorker {
   queueName;
   workerId;
@@ -737,7 +794,7 @@ class JobQueueWorker {
       await this.storage.complete(this.classToStorage(job));
       this.events.emit("job_complete", job.id, output);
     } catch (err) {
-      console.error("completeJob errored:", err);
+      getLogger().error("completeJob errored:", { error: err });
     } finally {
       this.cleanupJob(job.id);
     }
@@ -754,7 +811,7 @@ class JobQueueWorker {
       await this.storage.complete(this.classToStorage(job));
       this.events.emit("job_error", job.id, error.message, error.constructor.name);
     } catch (err) {
-      console.error("failJob errored:", err);
+      getLogger().error("failJob errored:", { error: err });
     } finally {
       this.cleanupJob(job.id);
     }
@@ -769,7 +826,7 @@ class JobQueueWorker {
       await this.storage.complete(this.classToStorage(job));
       this.events.emit("job_disabled", job.id);
     } catch (err) {
-      console.error("disableJob errored:", err);
+      getLogger().error("disableJob errored:", { error: err });
     } finally {
       this.cleanupJob(job.id);
     }
@@ -786,7 +843,7 @@ class JobQueueWorker {
       await this.storage.complete(this.classToStorage(job));
       this.events.emit("job_retry", job.id, job.runAfter);
     } catch (err) {
-      console.error("rescheduleJob errored:", err);
+      getLogger().error("rescheduleJob errored:", { error: err });
     }
   }
   createAbortController(jobId) {
@@ -803,7 +860,7 @@ class JobQueueWorker {
   async handleAbort(jobId) {
     const job = await this.getJob(jobId);
     if (!job) {
-      console.error("handleAbort: job not found", jobId);
+      getLogger().error("handleAbort: job not found", { jobId });
       return;
     }
     const error = new AbortSignalJobError("Job Aborted");
@@ -837,7 +894,7 @@ class JobQueueWorker {
       return err;
     }
     if (err instanceof Error) {
-      return new PermanentJobError(err.message);
+      return new PermanentJobError(withJobErrorDiagnostics(err.message, err));
     }
     return new PermanentJobError(String(err));
   }
@@ -1146,10 +1203,10 @@ class CompositeLimiter {
     return true;
   }
   async recordJobStart() {
-    this.limiters.forEach((limiter) => limiter.recordJobStart());
+    await Promise.all(this.limiters.map((limiter) => limiter.recordJobStart()));
   }
   async recordJobCompletion() {
-    this.limiters.forEach((limiter) => limiter.recordJobCompletion());
+    await Promise.all(this.limiters.map((limiter) => limiter.recordJobCompletion()));
   }
   async getNextAvailableTime() {
     let maxDate = new Date;
@@ -1167,7 +1224,7 @@ class CompositeLimiter {
     }
   }
   async clear() {
-    this.limiters.forEach((limiter) => limiter.clear());
+    await Promise.all(this.limiters.map((limiter) => limiter.clear()));
   }
 }
 
@@ -1405,8 +1462,11 @@ class RateLimiter {
   }
 }
 export {
+  withJobErrorDiagnostics,
   storageToClass,
+  formatErrorChainForDiagnostics,
   classToStorage,
+  applyPersistedDiagnosticsToStack,
   RetryableJobError,
   RateLimiter,
   PermanentJobError,
@@ -1421,6 +1481,7 @@ export {
   JobDisabledError,
   Job,
   JOB_LIMITER,
+  JOB_ERROR_DIAGNOSTICS_MARKER,
   EvenlySpacedRateLimiter,
   EVENLY_SPACED_JOB_RATE_LIMITER,
   DelayLimiter,
@@ -1430,4 +1491,4 @@ export {
   AbortSignalJobError
 };
 
-//# debugId=9CBA07AF2D8BC8F364756E2164756E21
+//# debugId=9EA74A4E777F02B264756E2164756E21