bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/cloud/commands.js

@@ -1,346 +1,9 @@
-/**
- * Cloud Command Definitions
- * Whitelisted commands that the dashboard can execute via WebSocket.
- */
-import { jobId } from '../../domain/types/job';
-/** Helper: derive job state from timestamps */
-function deriveState(j) {
-    if (j.completedAt)
-        return 'completed';
-    if (j.startedAt)
-        return 'active';
-    if (j.runAt > Date.now())
-        return 'delayed';
-    return 'waiting';
-}
-/** Helper: map job to frontend format (field names aligned with dashboard) */
-// eslint-disable-next-line complexity
-function mapJob(j) {
-    const data = j.data;
-    const state = deriveState(j);
-    const processTime = j.completedAt && j.startedAt ? j.completedAt - j.startedAt : undefined;
-    return {
-        id: String(j.id),
-        name: data?.name ?? 'default',
-        queueName: j.queue,
-        _queue: j.queue,
-        state,
-        _status: state,
-        data: data !== undefined ? JSON.stringify(data) : undefined,
-        priority: j.priority,
-        timestamp: j.createdAt,
-        processedOn: j.startedAt ?? undefined,
-        finishedOn: j.completedAt ?? undefined,
-        runAt: j.runAt,
-        failedReason: state === 'active' && j.attempts > 0 ? `Retry ${j.attempts}/${j.maxAttempts}` : undefined,
-        attemptsMade: j.attempts,
-        maxAttempts: j.maxAttempts,
-        backoff: j.backoff,
-        timeout: j.timeout ?? undefined,
-        ttl: j.ttl ?? undefined,
-        duration: processTime,
-        waitTime: j.startedAt ? j.startedAt - j.createdAt : undefined,
-        totalDuration: j.completedAt ? j.completedAt - j.createdAt : undefined,
-        progress: j.progress || undefined,
-        progressMessage: j.progressMessage ?? undefined,
-        customId: j.customId ?? undefined,
-        uniqueKey: j.uniqueKey ?? undefined,
-        tags: j.tags.length > 0 ? j.tags : undefined,
-        groupId: j.groupId ?? undefined,
-        parentId: j.parentId ? String(j.parentId) : undefined,
-        childrenIds: j.childrenIds.length > 0 ? j.childrenIds.map(String) : undefined,
-        dependsOn: j.dependsOn.length > 0 ? j.dependsOn.map(String) : undefined,
-        childrenCompleted: j.childrenCompleted > 0 ? j.childrenCompleted : undefined,
-        lastHeartbeat: j.lastHeartbeat > 0 ? j.lastHeartbeat : undefined,
-        stallCount: j.stallCount > 0 ? j.stallCount : undefined,
-        stallTimeout: j.stallTimeout ?? undefined,
-        removeOnComplete: j.removeOnComplete || undefined,
-        removeOnFail: j.removeOnFail || undefined,
-        lifo: j.lifo || undefined,
-        backoffConfig: j.backoffConfig ?? undefined,
-        repeat: j.repeat ?? undefined,
-        stackTraceLimit: j.stackTraceLimit,
-        keepLogs: j.keepLogs ?? undefined,
-        sizeLimit: j.sizeLimit ?? undefined,
-        failParentOnFailure: j.failParentOnFailure || undefined,
-        removeDependencyOnFailure: j.removeDependencyOnFailure || undefined,
-        continueParentOnFailure: j.continueParentOnFailure || undefined,
-        ignoreDependencyOnFailure: j.ignoreDependencyOnFailure || undefined,
-        deduplicationTtl: j.deduplicationTtl ?? undefined,
-        deduplicationExtend: j.deduplicationExtend || undefined,
-        deduplicationReplace: j.deduplicationReplace || undefined,
-        debounceId: j.debounceId ?? undefined,
-        debounceTtl: j.debounceTtl ?? undefined,
-        timeline: j.timeline.length > 0 ? j.timeline : undefined,
-    };
-}
-/** All whitelisted commands */
+/** Whitelisted commands that the cloud dashboard may execute. */
+import { INTEGRATION_COMMANDS } from './commands/integrations';
+import { JOB_COMMANDS } from './commands/jobs';
+import { QUEUE_COMMANDS } from './commands/queues';
 export const COMMANDS = {
-    // --- Queue control ---
-    'queue:pause': (qm, cmd) => {
-        qm.pause(cmd.queue ?? '');
-        return { queue: cmd.queue, paused: true };
-    },
-    'queue:resume': (qm, cmd) => {
-        qm.resume(cmd.queue ?? '');
-        return { queue: cmd.queue, paused: false };
-    },
-    'queue:drain': (qm, cmd) => {
-        const count = qm.drain(cmd.queue ?? '');
-        return { queue: cmd.queue, drained: count };
-    },
-    'queue:clean': (qm, cmd) => {
-        const ids = qm.clean(cmd.queue ?? '', cmd.graceMs ?? 0, cmd.state, cmd.limit);
-        return { queue: cmd.queue, cleaned: ids.length, ids };
-    },
-    'queue:obliterate': (qm, cmd) => {
-        qm.obliterate(cmd.queue ?? '');
-        return { queue: cmd.queue, obliterated: true };
-    },
-    'queue:promoteAll': async (qm, cmd) => {
-        const limit = cmd.limit ?? 1000;
-        const jobs = qm.getJobs(cmd.queue ?? '', { state: ['delayed'], start: 0, end: limit - 1 });
-        let promoted = 0;
-        for (const j of jobs) {
-            try {
-                await qm.promote(j.id);
-                promoted++;
-            }
-            catch {
-                // skip
-            }
-        }
-        return { queue: cmd.queue, promoted };
-    },
-    'queue:retryCompleted': (qm, cmd) => {
-        const count = qm.retryCompleted(cmd.queue ?? '');
-        return { queue: cmd.queue, retried: count };
-    },
-    // --- Queue config ---
-    'queue:rateLimit': (qm, cmd) => {
-        qm.setRateLimit(cmd.queue ?? '', cmd.max ?? 100);
-        return { queue: cmd.queue, rateLimit: cmd.max ?? 100 };
-    },
-    'queue:clearRateLimit': (qm, cmd) => {
-        qm.clearRateLimit(cmd.queue ?? '');
-        return { queue: cmd.queue, rateLimit: null };
-    },
-    'queue:concurrency': (qm, cmd) => {
-        qm.setConcurrency(cmd.queue ?? '', cmd.concurrency ?? 10);
-        return { queue: cmd.queue, concurrency: cmd.concurrency ?? 10 };
-    },
-    'queue:clearConcurrency': (qm, cmd) => {
-        qm.clearConcurrency(cmd.queue ?? '');
-        return { queue: cmd.queue, concurrency: null };
-    },
-    'queue:stallConfig': (qm, cmd) => {
-        qm.setStallConfig(cmd.queue ?? '', cmd.config ?? {});
-        return { queue: cmd.queue, stallConfig: cmd.config };
-    },
-    'queue:dlqConfig': (qm, cmd) => {
-        qm.setDlqConfig(cmd.queue ?? '', cmd.config ?? {});
-        return { queue: cmd.queue, dlqConfig: cmd.config };
-    },
-    // --- Queue detail ---
-    'queue:detail': (qm, cmd) => {
-        const queue = cmd.queue ?? '';
-        const counts = qm.getQueueJobCounts(queue);
-        const paused = qm.isPaused(queue);
-        const stallConfig = qm.getStallConfig(queue);
-        const dlqConfig = qm.getDlqConfig(queue);
-        const dlqEntries = qm.getDlqEntries(queue).slice(0, 50);
-        const jobs = qm.getJobs(queue, {
-            state: ['waiting', 'active', 'delayed', 'completed', 'failed'],
-            start: 0,
-            end: 49,
-        });
-        return {
-            queue,
-            paused,
-            counts,
-            stallConfig: {
-                enabled: stallConfig.enabled,
-                stallInterval: stallConfig.stallInterval,
-                maxStalls: stallConfig.maxStalls,
-            },
-            dlqConfig: { maxRetries: dlqConfig.maxAutoRetries, maxAge: dlqConfig.maxAge ?? 0 },
-            dlqEntries: dlqEntries.map((e) => ({
-                jobId: String(e.job.id),
-                reason: e.reason,
-                error: e.error,
-                enteredAt: e.enteredAt,
-                retryCount: e.retryCount,
-            })),
-            jobs: jobs.map(mapJob),
-        };
-    },
-    // --- Job operations ---
-    'job:cancel': async (qm, cmd) => {
-        const ok = await qm.cancel(jobId(cmd.jobId ?? ''));
-        return { cancelled: ok };
-    },
-    'job:promote': async (qm, cmd) => {
-        const ok = await qm.promote(jobId(cmd.jobId ?? ''));
-        return { promoted: ok };
-    },
-    'job:push': async (qm, cmd) => {
-        const job = await qm.push(cmd.queue ?? '', {
-            data: cmd.data ?? {},
-            priority: cmd.priority,
-            delay: cmd.delay,
-        });
-        return { jobId: String(job.id), queue: cmd.queue };
-    },
-    'job:priority': async (qm, cmd) => {
-        const ok = await qm.changePriority(jobId(cmd.jobId ?? ''), cmd.priority ?? 0);
-        return { changed: ok };
-    },
-    'job:discard': async (qm, cmd) => {
-        const ok = await qm.discard(jobId(cmd.jobId ?? ''));
-        return { discarded: ok };
-    },
-    'job:delay': async (qm, cmd) => {
-        await qm.changeDelay(jobId(cmd.jobId ?? ''), cmd.delay ?? 0);
-        return { delayed: true };
-    },
-    'job:updateData': async (qm, cmd) => {
-        const ok = await qm.updateJobData(jobId(cmd.jobId ?? ''), cmd.data);
-        return { updated: ok };
-    },
-    'job:clearLogs': (qm, cmd) => {
-        qm.clearLogs(jobId(cmd.jobId ?? ''), cmd.keepLogs);
-        return { cleared: true };
-    },
-    // --- Job queries ---
-    'job:retry': (qm, cmd) => {
-        if (cmd.queue) {
-            const count = qm.retryDlq(cmd.queue, cmd.jobId ? jobId(cmd.jobId) : undefined);
-            return { retried: count };
-        }
-        return { retried: 0 };
-    },
-    'job:logs': (qm, cmd) => {
-        const logs = qm.getLogs(jobId(cmd.jobId ?? ''));
-        return { logs };
-    },
-    'job:result': (qm, cmd) => {
-        const result = qm.getResult(jobId(cmd.jobId ?? ''));
-        return { result: result ?? null };
-    },
-    'job:list': (qm, cmd) => {
-        const limit = cmd.limit ?? 50;
-        const offset = cmd.offset ?? 0;
-        const states = cmd.state
-            ? cmd.state.split(',')
-            : ['waiting', 'active', 'delayed', 'completed', 'failed'];
-        const jobs = qm.getJobs(cmd.queue ?? '', {
-            state: states,
-            start: offset,
-            end: offset + limit - 1,
-        });
-        return { jobs: jobs.map(mapJob), total: qm.count(cmd.queue ?? ''), offset, limit };
-    },
-    'job:get': async (qm, cmd) => {
-        const job = await qm.getJob(jobId(cmd.jobId ?? ''));
-        if (!job)
-            return { job: null };
-        const mapped = mapJob(job);
-        return {
-            job: {
-                ...mapped,
-                logs: qm.getLogs(jobId(cmd.jobId ?? '')),
-                result: qm.getResult(jobId(cmd.jobId ?? '')) ?? null,
-            },
-        };
-    },
-    // --- DLQ ---
-    'dlq:retry': (qm, cmd) => {
-        const count = qm.retryDlq(cmd.queue ?? '', cmd.jobId ? jobId(cmd.jobId) : undefined);
-        return { retried: count };
-    },
-    'dlq:purge': (qm, cmd) => {
-        const count = qm.purgeDlq(cmd.queue ?? '');
-        return { purged: count };
-    },
-    // --- Cron ---
-    'cron:upsert': (qm, cmd) => {
-        qm.removeCron(cmd.name ?? '');
-        const cron = qm.addCron({
-            name: cmd.name ?? '',
-            queue: cmd.queue ?? '',
-            data: cmd.data ?? {},
-            schedule: cmd.schedule,
-        });
-        return { name: cron.name, nextRun: cron.nextRun };
-    },
-    'cron:delete': (qm, cmd) => {
-        const ok = qm.removeCron(cmd.name ?? '');
-        return { deleted: ok };
-    },
-    // --- Webhooks ---
-    'webhook:add': (qm, cmd) => {
-        const wh = qm.webhookManager.add(cmd.url ?? '', cmd.events ?? [], cmd.queue ?? undefined, cmd.secret ?? undefined);
-        return { id: wh.id, url: wh.url, events: wh.events };
-    },
-    'webhook:remove': (qm, cmd) => {
-        const ok = qm.webhookManager.remove(cmd.webhookId ?? '');
-        return { removed: ok };
-    },
-    'webhook:set-enabled': (qm, cmd) => {
-        const ok = qm.webhookManager.setEnabled(cmd.webhookId ?? '', cmd.enabled ?? true);
-        return { updated: ok };
-    },
-    // --- List all jobs across all queues ---
-    'job:listAll': (qm, cmd) => {
-        const limit = cmd.limit ?? 50;
-        const offset = cmd.offset ?? 0;
-        const states = cmd.state
-            ? cmd.state.split(',')
-            : ['waiting', 'active', 'delayed', 'completed', 'failed'];
-        const queueNames = qm.listQueues();
-        const allJobs = [];
-        for (const name of queueNames) {
-            const jobs = qm.getJobs(name, { state: states, start: 0, end: 999 });
-            for (const j of jobs)
-                allJobs.push(mapJob(j));
-        }
-        // Sort by createdAt descending
-        allJobs.sort((a, b) => b.timestamp - a.timestamp);
-        return { jobs: allJobs.slice(offset, offset + limit), total: allJobs.length, offset, limit };
-    },
-    // --- Queue list ---
-    'queue:list': (qm) => {
-        const queueNames = qm.listQueues();
-        const countsByQueue = qm.getAllQueueJobCounts();
-        const queues = queueNames.flatMap((name) => {
-            const counts = countsByQueue.get(name);
-            if (!counts)
-                return [];
-            return {
-                name,
-                waiting: counts.waiting,
-                prioritized: counts.prioritized,
-                delayed: counts.delayed,
-                active: counts.active,
-                completed: counts.completed,
-                failed: counts.failed,
-                'waiting-children': counts['waiting-children'],
-                paused: qm.isPaused(name),
-                totalCompleted: counts.totalCompleted,
-                totalFailed: counts.totalFailed,
-            };
-        });
-        return { queues };
-    },
-    // --- Stats & backup ---
-    'stats:refresh': (qm) => {
-        return qm.getStats();
-    },
-    's3:backup': async (qm) => {
-        const handles = qm.serverHandles;
-        if (handles?.triggerBackup) {
-            return await handles.triggerBackup();
-        }
-        return { error: 'S3 backup not configured' };
-    },
+    ...QUEUE_COMMANDS,
+    ...JOB_COMMANDS,
+    ...INTEGRATION_COMMANDS,
 };

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

@@ -0,0 +1,16 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudSnapshot } from '../types';
+export declare function collectQueueThroughput(queues: Array<{
+    name: string;
+    totalCompleted: number;
+    totalFailed: number;
+}>): CloudSnapshot['queueThroughput'];
+export declare function collectWorkerUtilization(queueManager: QueueManager): CloudSnapshot['workerUtilization'];
+export declare function collectDurationHistogram(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['durationHistogram'];
+export declare function collectQueueWaitTime(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueWaitTime'];
+export declare function collectQueueRetryRate(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueRetryRate'];
+export declare function collectBacklogVelocity(queues: Array<{
+    name: string;
+    waiting: number;
+}>): CloudSnapshot['queueBacklogVelocity'];
+export declare function collectPriorityDistribution(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queuePriorityDistribution'];

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

@@ -0,0 +1,132 @@
+const previousQueueTotals = new Map();
+const previousQueueWaiting = new Map();
+export function collectQueueThroughput(queues) {
+    const now = Date.now();
+    const result = {};
+    for (const queue of queues) {
+        const previous = previousQueueTotals.get(queue.name);
+        const total = queue.totalCompleted + queue.totalFailed;
+        if (previous) {
+            const elapsedSec = (now - previous.timestamp) / 1000;
+            if (elapsedSec > 0.5) {
+                const completeDelta = queue.totalCompleted - previous.completed;
+                const failDelta = queue.totalFailed - previous.failed;
+                result[queue.name] = {
+                    pushPerSec: Math.round(((completeDelta + failDelta) / elapsedSec) * 100) / 100,
+                    completePerSec: Math.round((completeDelta / elapsedSec) * 100) / 100,
+                    failPerSec: Math.round((failDelta / elapsedSec) * 100) / 100,
+                    errorRate: total > 0 ? Math.round((queue.totalFailed / total) * 10000) / 10000 : 0,
+                };
+            }
+        }
+        previousQueueTotals.set(queue.name, {
+            completed: queue.totalCompleted,
+            failed: queue.totalFailed,
+            pushed: queue.totalCompleted + queue.totalFailed,
+            timestamp: now,
+        });
+    }
+    return result;
+}
+export function collectWorkerUtilization(queueManager) {
+    return queueManager.workerManager.list().map((worker) => ({
+        id: worker.id,
+        name: worker.name,
+        utilization: worker.concurrency > 0 ? Math.round((worker.activeJobs / worker.concurrency) * 100) / 100 : 0,
+    }));
+}
+export function collectDurationHistogram(recentJobs) {
+    const histogram = { lt100ms: 0, lt1s: 0, lt10s: 0, lt60s: 0, gt60s: 0 };
+    for (const job of recentJobs) {
+        if (!job.duration)
+            continue;
+        if (job.duration < 100)
+            histogram.lt100ms++;
+        else if (job.duration < 1000)
+            histogram.lt1s++;
+        else if (job.duration < 10000)
+            histogram.lt10s++;
+        else if (job.duration < 60000)
+            histogram.lt60s++;
+        else
+            histogram.gt60s++;
+    }
+    return histogram;
+}
+export function collectQueueWaitTime(recentJobs) {
+    const byQueue = new Map();
+    for (const job of recentJobs) {
+        if (!job.startedAt || !job.createdAt)
+            continue;
+        const wait = job.startedAt - job.createdAt;
+        if (wait < 0)
+            continue;
+        let waits = byQueue.get(job.queue);
+        if (!waits) {
+            waits = [];
+            byQueue.set(job.queue, waits);
+        }
+        waits.push(wait);
+    }
+    const result = {};
+    for (const [queue, waits] of byQueue) {
+        const sum = waits.reduce((a, b) => a + b, 0);
+        result[queue] = {
+            avgMs: Math.round(sum / waits.length),
+            maxMs: Math.max(...waits),
+            minMs: Math.min(...waits),
+        };
+    }
+    return result;
+}
+export function collectQueueRetryRate(recentJobs) {
+    const byQueue = new Map();
+    for (const job of recentJobs) {
+        let entry = byQueue.get(job.queue);
+        if (!entry) {
+            entry = { retrying: 0, total: 0 };
+            byQueue.set(job.queue, entry);
+        }
+        entry.total++;
+        if (job.attempts > 0)
+            entry.retrying++;
+    }
+    const result = {};
+    for (const [queue, data] of byQueue) {
+        result[queue] = {
+            retryRate: data.total > 0 ? Math.round((data.retrying / data.total) * 10000) / 10000 : 0,
+            retrying: data.retrying,
+            total: data.total,
+        };
+    }
+    return result;
+}
+export function collectBacklogVelocity(queues) {
+    const now = Date.now();
+    const result = {};
+    for (const queue of queues) {
+        const previous = previousQueueWaiting.get(queue.name);
+        if (previous) {
+            const elapsedMin = (now - previous.timestamp) / 60000;
+            if (elapsedMin > 0.1) {
+                const delta = queue.waiting - previous.waiting;
+                const deltaPerMin = Math.round((delta / elapsedMin) * 100) / 100;
+                result[queue.name] = {
+                    deltaWaiting: delta,
+                    deltaPerMin,
+                    trend: deltaPerMin > 5 ? 'growing' : deltaPerMin < -5 ? 'shrinking' : 'stable',
+                };
+            }
+        }
+        previousQueueWaiting.set(queue.name, { waiting: queue.waiting, timestamp: now });
+    }
+    return result;
+}
+export function collectPriorityDistribution(recentJobs) {
+    const result = {};
+    for (const job of recentJobs) {
+        result[job.queue] ??= {};
+        result[job.queue][job.priority] = (result[job.queue][job.priority] ?? 0) + 1;
+    }
+    return result;
+}

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

@@ -0,0 +1,24 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudSnapshot } from '../types';
+import type { CollectSnapshotParams } from '../types/collector';
+/** Cached host and runtime metadata. */
+export declare const SNAPSHOT_HOST: string;
+export declare const SNAPSHOT_RUNTIME: {
+    bunVersion: string;
+    os: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    cpus: number;
+};
+/** Resolve redaction options with defaults (includeJobData defaults on). */
+export declare function resolveRedaction(params: CollectSnapshotParams): {
+    redactFields: readonly string[];
+    includeJobData: boolean;
+};
+/** Map cron definitions to their snapshot shape. */
+export declare function collectCrons(queueManager: QueueManager): CloudSnapshot['crons'];
+/** Back-fill failed-job timing from the last DLQ attempt. */
+export declare function enrichFailedJobDurations(recentJobs: CloudSnapshot['recentJobs'], dlqEntries: CloudSnapshot['dlqEntries']): void;
+/** Collect worker registry details and derived health fields. */
+export declare function collectWorkerDetails(queueManager: QueueManager, now: number): CloudSnapshot['workerDetails'];
+/** Collect results, logs, and active locks for the snapshot. */
+export declare function collectJobArtifacts(queueManager: QueueManager): Pick<CloudSnapshot, 'jobResults' | 'jobLogEntries' | 'activeLocks'>;

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

@@ -0,0 +1,105 @@
+import { arch, cpus, hostname, platform } from 'os';
+/** Cached host and runtime metadata. */
+export const SNAPSHOT_HOST = hostname();
+export const SNAPSHOT_RUNTIME = {
+    bunVersion: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
+    os: platform(),
+    arch: arch(),
+    cpus: cpus().length,
+};
+/** Resolve redaction options with defaults (includeJobData defaults on). */
+export function resolveRedaction(params) {
+    return {
+        redactFields: params.redactFields ?? [],
+        includeJobData: params.includeJobData ?? true,
+    };
+}
+/** Map cron definitions to their snapshot shape. */
+export function collectCrons(queueManager) {
+    return queueManager.listCrons().map((cron) => ({
+        name: cron.name,
+        queue: cron.queue,
+        schedule: cron.schedule ?? null,
+        repeatEvery: cron.repeatEvery ?? null,
+        nextRun: cron.nextRun,
+        executions: cron.executions,
+        maxLimit: cron.maxLimit,
+        lastRun: cron.executions > 0 && cron.repeatEvery ? cron.nextRun - cron.repeatEvery : null,
+        priority: cron.priority,
+        timezone: cron.timezone ?? null,
+        data: cron.data,
+        uniqueKey: cron.uniqueKey ?? null,
+        dedup: cron.dedup ?? null,
+    }));
+}
+/** Back-fill failed-job timing from the last DLQ attempt. */
+export function enrichFailedJobDurations(recentJobs, dlqEntries) {
+    if (dlqEntries.length === 0)
+        return;
+    const dlqMap = new Map();
+    for (const entry of dlqEntries) {
+        if (entry.attemptHistory.length > 0) {
+            const last = entry.attemptHistory[entry.attemptHistory.length - 1];
+            dlqMap.set(entry.jobId, { duration: last.duration, failedAt: last.failedAt });
+        }
+    }
+    for (const job of recentJobs) {
+        if (job.state === 'failed' && !job.duration) {
+            const dlq = dlqMap.get(job.id);
+            if (dlq) {
+                job.duration = dlq.duration;
+                job.completedAt = dlq.failedAt;
+                job.totalDuration = dlq.failedAt - job.createdAt;
+            }
+        }
+    }
+}
+/** Collect worker registry details and derived health fields. */
+export function collectWorkerDetails(queueManager, now) {
+    const workerTimeoutMs = 30_000;
+    return queueManager.workerManager.list().map((worker) => {
+        const totalJobs = worker.processedJobs + worker.failedJobs;
+        return {
+            id: worker.id,
+            name: worker.name,
+            queues: worker.queues,
+            concurrency: worker.concurrency,
+            hostname: worker.hostname,
+            pid: worker.pid,
+            registeredAt: worker.registeredAt,
+            lastSeen: worker.lastSeen,
+            activeJobs: worker.activeJobs,
+            processedJobs: worker.processedJobs,
+            failedJobs: worker.failedJobs,
+            currentJob: worker.currentJob,
+            uptime: now - worker.registeredAt,
+            status: now - worker.lastSeen > workerTimeoutMs
+                ? 'stalled'
+                : worker.activeJobs > 0
+                    ? 'active'
+                    : 'idle',
+            errorRate: totalJobs > 0 ? +(worker.failedJobs / totalJobs).toFixed(4) : 0,
+            utilization: worker.concurrency > 0 ? +(worker.activeJobs / worker.concurrency).toFixed(4) : 0,
+        };
+    });
+}
+/** Collect results, logs, and active locks for the snapshot. */
+export function collectJobArtifacts(queueManager) {
+    const jobResults = {};
+    for (const [id, value] of queueManager.getAllJobResults())
+        jobResults[id] = value;
+    const jobLogEntries = {};
+    for (const [id, logs] of queueManager.getAllJobLogs())
+        jobLogEntries[id] = logs;
+    const activeLocks = [...queueManager.getAllJobLocks().values()].map((lock) => ({
+        jobId: String(lock.jobId),
+        owner: lock.owner,
+        token: lock.token,
+        createdAt: lock.createdAt,
+        expiresAt: lock.expiresAt,
+        lastRenewalAt: lock.lastRenewalAt,
+        renewalCount: lock.renewalCount,
+        ttl: lock.ttl,
+    }));
+    return { jobResults, jobLogEntries, activeLocks };
+}

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

@@ -0,0 +1,5 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudSnapshot } from '../types';
+export declare function collectQueueConfigs(queueManager: QueueManager, queueNames: Set<string>): CloudSnapshot['queueConfigs'];
+export declare function collectWebhooks(queueManager: QueueManager): CloudSnapshot['webhooks'];
+export declare function collectTopErrors(queueManager: QueueManager, dlqQueueNames: string[]): CloudSnapshot['topErrors'];