bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/cloud/snapshot/config.js

@@ -0,0 +1,86 @@
+export function collectQueueConfigs(queueManager, queueNames) {
+    const configs = {};
+    const perQueue = queueManager.getPerQueueStats();
+    for (const name of queueNames) {
+        try {
+            const stall = queueManager.getStallConfig(name);
+            const dlq = queueManager.getDlqConfig(name);
+            const queueStats = perQueue.get(name);
+            const limits = queueManager.getQueueLimits(name);
+            configs[name] = {
+                paused: queueManager.isPaused(name),
+                rateLimit: limits.rateLimit,
+                concurrencyLimit: limits.concurrencyLimit,
+                concurrencyActive: queueStats?.active ?? 0,
+                stallConfig: {
+                    enabled: stall.enabled,
+                    stallInterval: stall.stallInterval,
+                    maxStalls: stall.maxStalls,
+                    gracePeriod: stall.gracePeriod,
+                },
+                dlqConfig: {
+                    autoRetry: dlq.autoRetry,
+                    autoRetryInterval: dlq.autoRetryInterval,
+                    maxRetries: dlq.maxAutoRetries,
+                    maxAge: dlq.maxAge ?? 0,
+                    maxEntries: dlq.maxEntries,
+                },
+            };
+        }
+        catch {
+            // Skip queue on error.
+        }
+    }
+    return configs;
+}
+export function collectWebhooks(queueManager) {
+    try {
+        return queueManager.webhookManager.list().map((webhook) => ({
+            id: webhook.id,
+            url: webhook.url,
+            events: webhook.events,
+            queue: webhook.queue,
+            enabled: webhook.enabled,
+            successCount: webhook.successCount,
+            failureCount: webhook.failureCount,
+            lastTriggered: webhook.lastTriggered,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export function collectTopErrors(queueManager, dlqQueueNames) {
+    if (dlqQueueNames.length === 0)
+        return [];
+    const errorMap = new Map();
+    const entries = dlqQueueNames.flatMap((name) => {
+        try {
+            return queueManager.getDlqEntries(name);
+        }
+        catch {
+            return [];
+        }
+    });
+    for (const entry of entries) {
+        const message = entry.error ?? entry.reason;
+        const existing = errorMap.get(message);
+        if (existing) {
+            existing.count++;
+            if (entry.enteredAt > existing.lastSeen) {
+                existing.lastSeen = entry.enteredAt;
+                existing.queue = entry.job.queue;
+            }
+        }
+        else {
+            errorMap.set(message, {
+                count: 1,
+                queue: entry.job.queue,
+                lastSeen: entry.enteredAt,
+            });
+        }
+    }
+    return [...errorMap.entries()]
+        .map(([message, data]) => ({ message, ...data }))
+        .sort((a, b) => b.count - a.count);
+}

package/dist/infrastructure/cloud/snapshot/jobs.d.ts

@@ -0,0 +1,5 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudSnapshot } from '../types';
+import type { RedactOptions } from '../types/redact';
+export declare function collectLiveJobs(queueManager: QueueManager, queueNames: string[], redact: RedactOptions): CloudSnapshot['recentJobs'];
+export declare function collectDlqEntries(queueManager: QueueManager, dlqQueueNames: string[], redact: RedactOptions): CloudSnapshot['dlqEntries'];

package/dist/infrastructure/cloud/snapshot/jobs.js

@@ -0,0 +1,148 @@
+import { redactData } from '../redact';
+const ALL_STATES = [
+    'waiting',
+    'active',
+    'delayed',
+    'failed',
+    'completed',
+    'prioritized',
+    'paused',
+    'waiting-children',
+];
+function orUndef(value) {
+    return value || undefined;
+}
+function nullUndef(value) {
+    return value ?? undefined;
+}
+function posOrUndef(value) {
+    return value > 0 ? value : undefined;
+}
+function arrOrUndef(array) {
+    return array.length > 0 ? array : undefined;
+}
+function mapJobCore(job, state, redact) {
+    const data = job.data;
+    const safeData = redact.includeJobData ? redactData(data, redact.redactFields) : undefined;
+    const processTime = job.completedAt && job.startedAt ? job.completedAt - job.startedAt : undefined;
+    return {
+        id: String(job.id),
+        name: job.name,
+        queue: job.queue,
+        state,
+        data: safeData,
+        priority: job.priority,
+        createdAt: job.createdAt,
+        startedAt: nullUndef(job.startedAt),
+        completedAt: nullUndef(job.completedAt),
+        runAt: job.runAt,
+        failedReason: state === 'active' && job.attempts > 0
+            ? `Retry ${job.attempts}/${job.maxAttempts}`
+            : undefined,
+        attempts: job.attempts,
+        maxAttempts: job.maxAttempts,
+        backoff: job.backoff,
+        timeout: nullUndef(job.timeout),
+        ttl: nullUndef(job.ttl),
+        duration: processTime,
+        waitTime: job.startedAt ? job.startedAt - job.createdAt : undefined,
+        totalDuration: job.completedAt ? job.completedAt - job.createdAt : undefined,
+    };
+}
+function mapJobExtended(job) {
+    return {
+        timeline: job.timeline.length > 0 ? job.timeline : undefined,
+        progress: posOrUndef(job.progress),
+        progressMessage: nullUndef(job.progressMessage),
+        customId: nullUndef(job.customId),
+        uniqueKey: nullUndef(job.uniqueKey),
+        tags: arrOrUndef(job.tags),
+        groupId: nullUndef(job.groupId),
+        parentId: job.parentId ? String(job.parentId) : undefined,
+        childrenIds: job.childrenIds.length > 0 ? job.childrenIds.map(String) : undefined,
+        dependsOn: job.dependsOn.length > 0 ? job.dependsOn.map(String) : undefined,
+        childrenCompleted: posOrUndef(job.childrenCompleted),
+        lastHeartbeat: posOrUndef(job.lastHeartbeat),
+        stallCount: posOrUndef(job.stallCount),
+        stallTimeout: nullUndef(job.stallTimeout),
+        removeOnComplete: orUndef(job.removeOnComplete),
+        removeOnFail: orUndef(job.removeOnFail),
+        lifo: orUndef(job.lifo),
+        backoffConfig: nullUndef(job.backoffConfig),
+        repeat: nullUndef(job.repeat),
+        stackTraceLimit: job.stackTraceLimit,
+        keepLogs: nullUndef(job.keepLogs),
+        sizeLimit: nullUndef(job.sizeLimit),
+        failParentOnFailure: orUndef(job.failParentOnFailure),
+        removeDependencyOnFailure: orUndef(job.removeDependencyOnFailure),
+        continueParentOnFailure: orUndef(job.continueParentOnFailure),
+        ignoreDependencyOnFailure: orUndef(job.ignoreDependencyOnFailure),
+        deduplicationTtl: nullUndef(job.deduplicationTtl),
+        deduplicationExtend: orUndef(job.deduplicationExtend),
+        deduplicationReplace: orUndef(job.deduplicationReplace),
+        debounceId: nullUndef(job.debounceId),
+        debounceTtl: nullUndef(job.debounceTtl),
+    };
+}
+function mapJobToSnapshot(job, state, redact) {
+    return { ...mapJobCore(job, state, redact), ...mapJobExtended(job) };
+}
+export function collectLiveJobs(queueManager, queueNames, redact) {
+    if (queueNames.length === 0)
+        return [];
+    const jobs = [];
+    for (const name of queueNames) {
+        for (const state of ALL_STATES) {
+            try {
+                const queueJobs = queueManager.getJobs(name, { state: [state], start: 0, end: 999 });
+                for (const job of queueJobs)
+                    jobs.push(mapJobToSnapshot(job, state, redact));
+            }
+            catch {
+                // Skip queue/state on error.
+            }
+        }
+    }
+    return jobs;
+}
+export function collectDlqEntries(queueManager, dlqQueueNames, redact) {
+    if (dlqQueueNames.length === 0)
+        return [];
+    const entries = [];
+    for (const name of dlqQueueNames) {
+        try {
+            for (const entry of queueManager.getDlqEntries(name)) {
+                entries.push({
+                    jobId: String(entry.job.id),
+                    queue: entry.job.queue,
+                    reason: entry.reason,
+                    error: entry.error,
+                    enteredAt: entry.enteredAt,
+                    retryCount: entry.retryCount,
+                    lastRetryAt: entry.lastRetryAt ?? undefined,
+                    nextRetryAt: entry.nextRetryAt ?? undefined,
+                    expiresAt: entry.expiresAt ?? undefined,
+                    jobAttempts: entry.job.attempts,
+                    jobMaxAttempts: entry.job.maxAttempts,
+                    jobData: redact.includeJobData
+                        ? redactData(entry.job.data, redact.redactFields)
+                        : undefined,
+                    jobCreatedAt: entry.job.createdAt,
+                    jobPriority: entry.job.priority,
+                    attemptHistory: entry.attempts.map((attempt) => ({
+                        attempt: attempt.attempt,
+                        startedAt: attempt.startedAt,
+                        failedAt: attempt.failedAt,
+                        reason: attempt.reason,
+                        error: attempt.error,
+                        duration: attempt.duration,
+                    })),
+                });
+            }
+        }
+        catch {
+            // Skip queue on error.
+        }
+    }
+    return entries.sort((a, b) => b.enteredAt - a.enteredAt);
+}

package/dist/infrastructure/cloud/snapshot/stalls.d.ts

@@ -0,0 +1,3 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudSnapshot } from '../types';
+export declare function collectStallDetails(queueManager: QueueManager): Promise<CloudSnapshot['stallDetails']>;

package/dist/infrastructure/cloud/snapshot/stalls.js

@@ -0,0 +1,34 @@
+import { jobId as toJobId } from '../../../domain/types/job';
+export async function collectStallDetails(queueManager) {
+    try {
+        if (queueManager.getMemoryStats().stalledCandidates === 0)
+            return [];
+        const stalledIds = queueManager
+            .stalledCandidates;
+        if (stalledIds.size === 0)
+            return [];
+        const now = Date.now();
+        const details = [];
+        for (const id of [...stalledIds].slice(0, 20)) {
+            try {
+                const job = await queueManager.getJob(toJobId(id));
+                if (!job)
+                    continue;
+                details.push({
+                    jobId: id,
+                    queue: job.queue,
+                    workerId: null,
+                    stalledAt: job.startedAt ?? now,
+                    stalledForMs: now - (job.startedAt ?? now),
+                });
+            }
+            catch {
+                // Skip job on error.
+            }
+        }
+        return details;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/infrastructure/cloud/snapshotCollector.d.ts

@@ -5,59 +5,8 @@
  * Light: stats, throughput, latency, memory, connections — O(SHARD_COUNT)
  * Heavy: recentJobs, dlqEntries, topErrors, workerDetails, queueConfigs, webhooks — O(queues × shards)
  */
-import type { QueueManager } from '../../application/queueManager';
 import type { CloudSnapshot } from './types';
-/** Optional server handles for connection stats + backup + storage */
-export interface ServerHandles {
-    getConnectionCount: () => number;
-    getWsClientCount: () => number;
-    getSseClientCount: () => number;
-    getBackupStatus?: () => {
-        enabled: boolean;
-        bucket: string;
-        endpoint: string;
-        intervalMs: number;
-        retention: number;
-        isRunning: boolean;
-    } | null;
-    getSqliteStats?: () => {
-        dbSizeBytes: number;
-        writeBufferPending: number;
-    } | null;
-    getMcpOperations?: () => {
-        operations: Array<{
-            tool: string;
-            queue: string | null;
-            timestamp: number;
-            durationMs: number;
-            success: boolean;
-            error: string | null;
-        }>;
-        summary: {
-            totalInvocations: number;
-            successCount: number;
-            failureCount: number;
-            avgDurationMs: number;
-            topTools: Array<{
-                tool: string;
-                count: number;
-            }>;
-        };
-    };
-}
-/** Parameters for snapshot collection */
-export interface CollectSnapshotParams {
-    queueManager: QueueManager;
-    instanceId: string;
-    instanceName: string;
-    startedAt: number;
-    sequenceId: number;
-    serverHandles?: ServerHandles;
-    includeHeavy: boolean;
-    /** Fields to redact from job data (mirrors CloudConfig.redactFields). Default: none */
-    redactFields?: readonly string[];
-    /** Include job data in recentJobs/dlqEntries (mirrors CloudConfig.includeJobData). Default: true */
-    includeJobData?: boolean;
-}
+import type { CollectSnapshotParams } from './types/collector';
+export type { CollectSnapshotParams, ServerHandles } from './types/collector';
 /** Collect a snapshot. Light data always fresh, heavy data cached between refreshes. */
 export declare function collectSnapshot(params: CollectSnapshotParams): Promise<CloudSnapshot>;

package/dist/infrastructure/cloud/snapshotCollector.js

@@ -5,69 +5,13 @@
  * Light: stats, throughput, latency, memory, connections — O(SHARD_COUNT)
  * Heavy: recentJobs, dlqEntries, topErrors, workerDetails, queueConfigs, webhooks — O(queues × shards)
  */
-import { hostname, arch, platform, cpus } from 'os';
 import { throughputTracker } from '../../application/throughputTracker';
 import { latencyTracker } from '../../application/latencyTracker';
 import { getTaskErrorStats } from '../../application/backgroundTasks';
 import { VERSION } from '../../shared/version';
 import { cloudLog } from './logger';
+import { SNAPSHOT_HOST, SNAPSHOT_RUNTIME, collectCrons, collectJobArtifacts, collectWorkerDetails, enrichFailedJobDurations, resolveRedaction, } from './snapshot/collector';
 import { collectLiveJobs, collectDlqEntries, collectTopErrors, collectQueueConfigs, collectWebhooks, collectQueueThroughput, collectWorkerUtilization, collectDurationHistogram, collectQueueWaitTime, collectQueueRetryRate, collectBacklogVelocity, collectStallDetails, collectPriorityDistribution, } from './snapshotHelpers';
-/** Cached hostname — computed once */
-const HOST = hostname();
-/** Cached runtime info — computed once */
-const RUNTIME = {
-    bunVersion: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
-    os: platform(),
-    arch: arch(),
-    cpus: cpus().length,
-};
-/** Enrich failed jobs in recentJobs with duration from DLQ attempt history */
-function enrichFailedJobDurations(recentJobs, dlqEntries) {
-    if (dlqEntries.length === 0)
-        return;
-    const dlqMap = new Map();
-    for (const e of dlqEntries) {
-        if (e.attemptHistory.length > 0) {
-            const last = e.attemptHistory[e.attemptHistory.length - 1];
-            dlqMap.set(e.jobId, { duration: last.duration, failedAt: last.failedAt });
-        }
-    }
-    for (const j of recentJobs) {
-        if (j.state === 'failed' && !j.duration) {
-            const dlq = dlqMap.get(j.id);
-            if (dlq) {
-                j.duration = dlq.duration;
-                j.completedAt = dlq.failedAt;
-                j.totalDuration = dlq.failedAt - j.createdAt;
-            }
-        }
-    }
-}
-/** Resolve redaction options with defaults (includeJobData defaults on). */
-function resolveRedaction(params) {
-    return {
-        redactFields: params.redactFields ?? [],
-        includeJobData: params.includeJobData ?? true,
-    };
-}
-/** Map cron definitions to snapshot shape */
-function collectCrons(queueManager) {
-    return queueManager.listCrons().map((c) => ({
-        name: c.name,
-        queue: c.queue,
-        schedule: c.schedule ?? null,
-        repeatEvery: c.repeatEvery ?? null,
-        nextRun: c.nextRun,
-        executions: c.executions,
-        maxLimit: c.maxLimit,
-        lastRun: c.executions > 0 && c.repeatEvery ? c.nextRun - c.repeatEvery : null,
-        priority: c.priority,
-        timezone: c.timezone ?? null,
-        data: c.data,
-        uniqueKey: c.uniqueKey ?? null,
-        dedup: c.dedup ?? null,
-    }));
-}
 /** Collect a snapshot. Light data always fresh, heavy data cached between refreshes. */
 export async function collectSnapshot(params) {
     const t0 = performance.now();
@@ -116,63 +60,17 @@ export async function collectSnapshot(params) {
     const dlqEntries = collectDlqEntries(queueManager, dlqQueues.map((q) => q.name), { redactFields, includeJobData });
     enrichFailedJobDurations(recentJobs, dlqEntries);
     const topErrors = collectTopErrors(queueManager, dlqQueues.map((q) => q.name));
-    const now = Date.now();
-    const WORKER_TIMEOUT_MS = 30_000;
-    const workerDetails = queueManager.workerManager.list().map((w) => {
-        const totalJobs = w.processedJobs + w.failedJobs;
-        return {
-            id: w.id,
-            name: w.name,
-            queues: w.queues,
-            concurrency: w.concurrency,
-            hostname: w.hostname,
-            pid: w.pid,
-            registeredAt: w.registeredAt,
-            lastSeen: w.lastSeen,
-            activeJobs: w.activeJobs,
-            processedJobs: w.processedJobs,
-            failedJobs: w.failedJobs,
-            currentJob: w.currentJob,
-            // Computed fields
-            uptime: now - w.registeredAt,
-            status: now - w.lastSeen > WORKER_TIMEOUT_MS
-                ? 'stalled'
-                : w.activeJobs > 0
-                    ? 'active'
-                    : 'idle',
-            errorRate: totalJobs > 0 ? +(w.failedJobs / totalJobs).toFixed(4) : 0,
-            utilization: w.concurrency > 0 ? +(w.activeJobs / w.concurrency).toFixed(4) : 0,
-        };
-    });
+    const workerDetails = collectWorkerDetails(queueManager, Date.now());
     const queueConfigs = collectQueueConfigs(queueManager, new Set(queueNames));
     const webhooks = collectWebhooks(queueManager);
     const s3Backup = serverHandles?.getBackupStatus?.() ?? null;
     const telemetry = queueManager.getCloudTelemetry(allQueueNames);
-    // Job results, logs, and locks
-    const jobResultsMap = queueManager.getAllJobResults();
-    const jobResults = {};
-    for (const [id, val] of jobResultsMap)
-        jobResults[id] = val;
-    const jobLogsMap = queueManager.getAllJobLogs();
-    const jobLogEntries = {};
-    for (const [id, logs] of jobLogsMap)
-        jobLogEntries[id] = logs;
-    const locksMap = queueManager.getAllJobLocks();
-    const activeLocks = [...locksMap.values()].map((l) => ({
-        jobId: String(l.jobId),
-        owner: l.owner,
-        token: l.token,
-        createdAt: l.createdAt,
-        expiresAt: l.expiresAt,
-        lastRenewalAt: l.lastRenewalAt,
-        renewalCount: l.renewalCount,
-        ttl: l.ttl,
-    }));
+    const { jobResults, jobLogEntries, activeLocks } = collectJobArtifacts(queueManager);
     const result = {
         instanceId,
         instanceName,
         version: VERSION,
-        hostname: HOST,
+        hostname: SNAPSHOT_HOST,
         pid: process.pid,
         startedAt,
         timestamp: Date.now(),
@@ -230,7 +128,7 @@ export async function collectSnapshot(params) {
         durationHistogram: collectDurationHistogram(recentJobs),
         workerUtilization: collectWorkerUtilization(queueManager),
         sqliteStats: serverHandles?.getSqliteStats?.() ?? null,
-        runtime: RUNTIME,
+        runtime: SNAPSHOT_RUNTIME,
         queueWaitTime: collectQueueWaitTime(recentJobs),
         queueRetryRate: collectQueueRetryRate(recentJobs),
         queueBacklogVelocity: collectBacklogVelocity(queues),

package/dist/infrastructure/cloud/snapshotHelpers.d.ts

@@ -1,45 +1,5 @@
-/**
- * Snapshot Helper Collectors
- * Heavy and analytics data collectors used by snapshotCollector.
- */
-import type { QueueManager } from '../../application/queueManager';
-import type { CloudSnapshot } from './types';
-/** Redaction options threaded from the cloud config into job-data collectors */
-export interface RedactOptions {
-    /** Fields to redact from job data (mirrors CloudConfig.redactFields) */
-    redactFields: readonly string[];
-    /** When false, omit job data entirely (mirrors CloudConfig.includeJobData) */
-    includeJobData: boolean;
-}
-export declare function collectLiveJobs(queueManager: QueueManager, queueNames: string[], redact: RedactOptions): CloudSnapshot['recentJobs'];
-/** Collect ALL DLQ entries — no cap */
-export declare function collectDlqEntries(queueManager: QueueManager, dlqQueueNames: string[], redact: RedactOptions): CloudSnapshot['dlqEntries'];
-/** Collect per-queue config */
-export declare function collectQueueConfigs(queueManager: QueueManager, queueNames: Set<string>): CloudSnapshot['queueConfigs'];
-/** Collect webhook delivery stats */
-export declare function collectWebhooks(queueManager: QueueManager): CloudSnapshot['webhooks'];
-/** Collect top errors — only from queues with DLQ entries */
-export declare function collectTopErrors(queueManager: QueueManager, dlqQueueNames: string[]): CloudSnapshot['topErrors'];
-/** Compute per-queue throughput from delta of totalCompleted/totalFailed */
-export declare function collectQueueThroughput(queues: Array<{
-    name: string;
-    totalCompleted: number;
-    totalFailed: number;
-}>): CloudSnapshot['queueThroughput'];
-/** Compute per-worker utilization */
-export declare function collectWorkerUtilization(queueManager: QueueManager): CloudSnapshot['workerUtilization'];
-/** Compute duration histogram from recent jobs */
-export declare function collectDurationHistogram(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['durationHistogram'];
-/** Compute per-queue wait time (createdAt → startedAt) from recent jobs */
-export declare function collectQueueWaitTime(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueWaitTime'];
-/** Compute per-queue retry rate from recent jobs */
-export declare function collectQueueRetryRate(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueRetryRate'];
-/** Compute queue backlog velocity (delta waiting between snapshots) */
-export declare function collectBacklogVelocity(queues: Array<{
-    name: string;
-    waiting: number;
-}>): CloudSnapshot['queueBacklogVelocity'];
-/** Collect stall details from processing shards */
-export declare function collectStallDetails(queueManager: QueueManager): Promise<CloudSnapshot['stallDetails']>;
-/** Compute per-queue priority distribution from recent jobs */
-export declare function collectPriorityDistribution(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queuePriorityDistribution'];
+export { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, } from './snapshot/analytics';
+export { collectQueueConfigs, collectTopErrors, collectWebhooks } from './snapshot/config';
+export { collectDlqEntries, collectLiveJobs } from './snapshot/jobs';
+export { collectStallDetails } from './snapshot/stalls';
+export type { RedactOptions } from './types/redact';