bunqueue 2.8.60 → 2.9.2

package/dist/infrastructure/cloud/queueAdapter/postgres.js

@@ -0,0 +1,188 @@
+import { DEFAULT_DLQ_CONFIG } from '../../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../../domain/types/stall';
+const EMPTY_COUNTS = {
+    waiting: 0,
+    prioritized: 0,
+    delayed: 0,
+    active: 0,
+    completed: 0,
+    failed: 0,
+    waitingChildren: 0,
+};
+function queueCounts(model) {
+    const result = new Map();
+    for (const row of model.counts) {
+        const counts = result.get(row.queue) ?? { ...EMPTY_COUNTS };
+        if (row.state === 'waiting-children')
+            counts.waitingChildren = row.count;
+        else
+            counts[row.state] = row.count;
+        result.set(row.queue, counts);
+    }
+    return result;
+}
+function queueTotals(model) {
+    const result = new Map();
+    for (const row of model.totals) {
+        const totals = result.get(row.queue) ?? { completed: 0n, failed: 0n };
+        totals[row.metricType] = row.count;
+        result.set(row.queue, totals);
+    }
+    return result;
+}
+function cloudCounts(counts, totals) {
+    return {
+        waiting: counts.waiting,
+        prioritized: counts.prioritized,
+        delayed: counts.delayed,
+        active: counts.active,
+        completed: counts.completed,
+        failed: counts.failed,
+        'waiting-children': counts.waitingChildren,
+        totalCompleted: Number(totals.completed),
+        totalFailed: Number(totals.failed),
+    };
+}
+function defaultQueueState(queue) {
+    return {
+        queue,
+        paused: false,
+        rateLimit: null,
+        rateDurationMs: null,
+        rateWindowStartedAt: null,
+        rateExpiresAt: null,
+        rateCount: 0,
+        concurrencyLimit: null,
+        stallConfig: DEFAULT_STALL_CONFIG,
+        dlqConfig: DEFAULT_DLQ_CONFIG,
+    };
+}
+/** PostgreSQL Cloud strategy; every shared surface goes through durable APIs. */
+export class PostgresCloudQueueAdapter {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    pause = (queue, paused) => this.manager.pauseDurable(queue, paused);
+    drain = (queue) => this.manager.drainDurable(queue);
+    clean = (queue, graceMs, state, limit) => this.manager.cleanDurable(queue, graceMs, state, limit);
+    obliterate = (queue) => this.manager.obliterateDurable(queue);
+    promoteAll = (queue, limit) => this.manager.promoteJobs(queue, limit);
+    retryCompleted = (queue) => this.manager.retryCompletedDurable(queue);
+    setRateLimit = (queue, limit) => this.manager.setRateLimitDurable(queue, limit, null);
+    setConcurrency = (queue, limit) => this.manager.setConcurrencyDurable(queue, limit);
+    setStallConfig = (queue, patch) => this.manager.setStallConfigDurable(queue, patch);
+    setDlqConfig = (queue, patch) => this.manager.setDlqConfigDurable(queue, patch);
+    listJobs = (queue, options) => this.manager.listCloudJobsDurable(queue, options);
+    getJob = (id) => this.manager.getJob(id);
+    getLogs = (id) => this.manager.getLogsDurable(id);
+    getResult = (id) => this.manager.getCloudResultDurable(id);
+    clearLogs = (id, keepLogs) => this.manager.clearLogsDurable(id, keepLogs);
+    retryDlq = (queue, id) => this.manager.retryDlqDurable(queue, id);
+    purgeDlq = (queue) => this.manager.purgeDlqDurable(queue);
+    push = (queue, input) => this.manager.push(queue, input);
+    cancel = (id) => this.manager.cancel(id);
+    promote = (id) => this.manager.promote(id);
+    changePriority = (id, priority) => this.manager.changePriority(id, priority);
+    discard = (id) => this.manager.discard(id);
+    changeDelay = (id, delay) => this.manager.changeDelay(id, delay);
+    updateData = (id, data) => this.manager.updateJobData(id, data);
+    addCron = (input) => this.manager.addCronDurable(input);
+    removeCron = (name) => this.manager.removeCronDurable(name);
+    async readSnapshotSource(requestedQueues = []) {
+        const model = await this.manager.readCloudSnapshotDurable();
+        const counts = queueCounts(model);
+        const totals = queueTotals(model);
+        const names = new Set([
+            ...model.queueStates.map(({ queue }) => queue),
+            ...counts.keys(),
+            ...totals.keys(),
+            ...model.jobs.map(({ job }) => job.queue),
+            ...requestedQueues,
+        ]);
+        const states = new Map(model.queueStates.map((state) => [state.queue, state]));
+        const queues = [...names].sort().map((name) => {
+            const state = states.get(name) ?? defaultQueueState(name);
+            const rateExpired = state.rateExpiresAt !== null && state.rateExpiresAt <= Date.now();
+            return {
+                name,
+                counts: cloudCounts(counts.get(name) ?? EMPTY_COUNTS, totals.get(name) ?? { completed: 0n, failed: 0n }),
+                paused: state.paused,
+                rateLimit: rateExpired ? null : state.rateLimit,
+                concurrencyLimit: state.concurrencyLimit,
+                stallConfig: state.stallConfig,
+                dlqConfig: state.dlqConfig,
+            };
+        });
+        return this.toSnapshotSource(model, queues);
+    }
+    toSnapshotSource(model, queues) {
+        const aggregate = [...queueCounts(model).values()].reduce((sum, counts) => ({
+            waiting: sum.waiting + counts.waiting,
+            prioritized: sum.prioritized + counts.prioritized,
+            delayed: sum.delayed + counts.delayed,
+            active: sum.active + counts.active,
+            completed: sum.completed + counts.completed,
+            failed: sum.failed + counts.failed,
+            waitingChildren: sum.waitingChildren + counts.waitingChildren,
+        }), { ...EMPTY_COUNTS });
+        const durableTotals = [...queueTotals(model).values()].reduce((sum, item) => ({
+            completed: sum.completed + item.completed,
+            failed: sum.failed + item.failed,
+        }), { completed: 0n, failed: 0n });
+        const localStats = this.manager.getCloudProcessStats();
+        const now = Date.now();
+        const activeWorkers = model.workers.filter((worker) => now - worker.lastSeen < 30_000);
+        const workerStats = {
+            total: model.workers.length,
+            active: activeWorkers.length,
+            totalProcessed: model.workers.reduce((sum, worker) => sum + worker.processedJobs, 0),
+            totalFailed: model.workers.reduce((sum, worker) => sum + worker.failedJobs, 0),
+            activeJobs: model.workers.reduce((sum, worker) => sum + worker.activeJobs, 0),
+            concurrencySlots: activeWorkers.reduce((sum, worker) => sum + worker.concurrency, 0),
+        };
+        const jobResults = new Map(model.results.map(({ jobId: id, result }) => [String(id), result]));
+        return {
+            stats: {
+                ...localStats,
+                waiting: aggregate.waiting,
+                prioritized: aggregate.prioritized,
+                delayed: aggregate.delayed,
+                active: aggregate.active,
+                completed: aggregate.completed,
+                dlq: aggregate.failed,
+                'waiting-children': aggregate.waitingChildren,
+                totalCompleted: durableTotals.completed,
+                totalFailed: durableTotals.failed,
+                cronJobs: model.crons.length,
+                cronPending: model.crons.filter((cron) => cron.nextRun <= now).length,
+            },
+            queues,
+            jobs: model.jobs.map((row) => ({ job: row.job, state: row.state })),
+            dlqEntries: model.jobs.flatMap((row) => (row.dlqEntry ? [row.dlqEntry] : [])),
+            workers: model.workers,
+            workerStats,
+            crons: model.crons,
+            jobResults,
+            jobLogs: model.logs,
+            activeLocks: model.jobs.flatMap((row) => {
+                if (row.state !== 'active' || !row.token || !row.leaseOwner || row.leaseUntil === null) {
+                    return [];
+                }
+                const lastRenewalAt = row.job.lastHeartbeat || row.job.startedAt || row.job.createdAt;
+                return [
+                    {
+                        jobId: String(row.job.id),
+                        owner: row.leaseOwner,
+                        token: row.token,
+                        createdAt: row.job.startedAt ?? row.job.createdAt,
+                        expiresAt: row.leaseUntil,
+                        lastRenewalAt,
+                        renewalCount: row.leaseRenewals,
+                        ttl: Math.max(0, row.leaseUntil - lastRenewalAt),
+                    },
+                ];
+            }),
+        };
+    }
+}

package/dist/infrastructure/cloud/queueAdapter/registry.d.ts

@@ -0,0 +1,4 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudQueueAdapter } from './types';
+/** Resolve one complete engine strategy and cache it for the manager lifetime. */
+export declare function resolveCloudQueueAdapter(manager: QueueManager): CloudQueueAdapter;

package/dist/infrastructure/cloud/queueAdapter/registry.js

@@ -0,0 +1,15 @@
+import { PostgresQueueManager } from '../../../application/postgresQueueManager';
+import { LocalCloudQueueAdapter } from './local';
+import { PostgresCloudQueueAdapter } from './postgres';
+const adapters = new WeakMap();
+/** Resolve one complete engine strategy and cache it for the manager lifetime. */
+export function resolveCloudQueueAdapter(manager) {
+    const existing = adapters.get(manager);
+    if (existing)
+        return existing;
+    const adapter = manager instanceof PostgresQueueManager
+        ? new PostgresCloudQueueAdapter(manager)
+        : new LocalCloudQueueAdapter(manager);
+    adapters.set(manager, adapter);
+    return adapter;
+}

package/dist/infrastructure/cloud/queueAdapter/types.d.ts

@@ -0,0 +1,87 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CronJob, CronJobInput } from '../../../domain/types/cron';
+import type { DlqConfig, DlqEntry } from '../../../domain/types/dlq';
+import type { Job, JobId } from '../../../domain/types/job';
+import type { StallConfig } from '../../../domain/types/stall';
+import type { JobLogEntry, Worker } from '../../../domain/types/worker';
+export interface CloudQueueCounts {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    completed: number;
+    failed: number;
+    'waiting-children': number;
+    totalCompleted: number;
+    totalFailed: number;
+}
+export interface CloudQueueSource {
+    readonly name: string;
+    readonly counts: CloudQueueCounts;
+    readonly paused: boolean;
+    readonly rateLimit: number | null;
+    readonly concurrencyLimit: number | null;
+    readonly stallConfig: StallConfig;
+    readonly dlqConfig: DlqConfig;
+}
+export interface CloudSourceJob {
+    readonly job: Job;
+    readonly state: string;
+}
+export interface CloudSourceLock {
+    readonly jobId: string;
+    readonly owner: string;
+    readonly token: string;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly lastRenewalAt: number;
+    readonly renewalCount: number;
+    readonly ttl: number;
+}
+export interface CloudSnapshotSource {
+    readonly stats: ReturnType<QueueManager['getStats']>;
+    readonly queues: readonly CloudQueueSource[];
+    readonly jobs: readonly CloudSourceJob[];
+    readonly dlqEntries: readonly DlqEntry[];
+    readonly workers: readonly Worker[];
+    readonly workerStats: ReturnType<QueueManager['workerManager']['getStats']>;
+    readonly crons: readonly CronJob[];
+    readonly jobResults: ReadonlyMap<string, unknown>;
+    readonly jobLogs: ReadonlyMap<string, readonly JobLogEntry[]>;
+    readonly activeLocks: readonly CloudSourceLock[];
+}
+export interface CloudQueueAdapter {
+    readonly manager: QueueManager;
+    pause(queue: string, paused: boolean): Promise<void>;
+    drain(queue: string): Promise<number>;
+    clean(queue: string, graceMs: number, state?: string, limit?: number): Promise<JobId[]>;
+    obliterate(queue: string): Promise<void>;
+    promoteAll(queue: string, limit: number): Promise<number>;
+    retryCompleted(queue: string): Promise<number>;
+    setRateLimit(queue: string, limit: number | null): Promise<void>;
+    setConcurrency(queue: string, limit: number | null): Promise<void>;
+    setStallConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    setDlqConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    listJobs(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<Job[]>;
+    getJob(id: JobId): Promise<Job | null>;
+    getLogs(id: JobId): Promise<JobLogEntry[]>;
+    getResult(id: JobId): Promise<unknown>;
+    clearLogs(id: JobId, keepLogs?: number): Promise<void>;
+    retryDlq(queue: string, id?: JobId): Promise<number>;
+    purgeDlq(queue: string): Promise<number>;
+    push(queue: string, input: Parameters<QueueManager['push']>[1]): Promise<Job>;
+    cancel(id: JobId): Promise<boolean>;
+    promote(id: JobId): Promise<boolean>;
+    changePriority(id: JobId, priority: number): Promise<boolean>;
+    discard(id: JobId): Promise<boolean>;
+    changeDelay(id: JobId, delay: number): Promise<boolean>;
+    updateData(id: JobId, data: unknown): Promise<boolean>;
+    addCron(input: CronJobInput): Promise<CronJob>;
+    removeCron(name: string): Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+}

package/dist/infrastructure/cloud/queueAdapter/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,11 +1,13 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
+import type { CloudSnapshotSource } from '../queueAdapter/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 mapSnapshotWorkerUtilization(workers: CloudSnapshotSource['workers']): 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'];

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

@@ -35,6 +35,13 @@ export function collectWorkerUtilization(queueManager) {
         utilization: worker.concurrency > 0 ? Math.round((worker.activeJobs / worker.concurrency) * 100) / 100 : 0,
     }));
 }
+export function mapSnapshotWorkerUtilization(workers) {
+    return workers.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) {

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

@@ -1,6 +1,7 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
 import type { CollectSnapshotParams } from '../types/collector';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
 /** Cached host and runtime metadata. */
 export declare const SNAPSHOT_HOST: string;
 export declare const SNAPSHOT_RUNTIME: {
@@ -16,9 +17,12 @@ export declare function resolveRedaction(params: CollectSnapshotParams): {
 };
 /** Map cron definitions to their snapshot shape. */
 export declare function collectCrons(queueManager: QueueManager): CloudSnapshot['crons'];
+export declare function mapSnapshotCrons(crons: CloudSnapshotSource['crons']): 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'];
+export declare function mapSnapshotWorkers(workers: CloudSnapshotSource['workers'], now: number): CloudSnapshot['workerDetails'];
 /** Collect results, logs, and active locks for the snapshot. */
 export declare function collectJobArtifacts(queueManager: QueueManager): Pick<CloudSnapshot, 'jobResults' | 'jobLogEntries' | 'activeLocks'>;
+export declare function mapSnapshotJobArtifacts(source: CloudSnapshotSource): Pick<CloudSnapshot, 'jobResults' | 'jobLogEntries' | 'activeLocks'>;

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

@@ -16,7 +16,10 @@ export function resolveRedaction(params) {
 }
 /** Map cron definitions to their snapshot shape. */
 export function collectCrons(queueManager) {
-    return queueManager.listCrons().map((cron) => ({
+    return mapSnapshotCrons(queueManager.listCrons());
+}
+export function mapSnapshotCrons(crons) {
+    return crons.map((cron) => ({
         name: cron.name,
         queue: cron.queue,
         schedule: cron.schedule ?? null,
@@ -83,6 +86,34 @@ export function collectWorkerDetails(queueManager, now) {
         };
     });
 }
+export function mapSnapshotWorkers(workers, now) {
+    const workerTimeoutMs = 30_000;
+    return workers.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 = {};
@@ -103,3 +134,10 @@ export function collectJobArtifacts(queueManager) {
     }));
     return { jobResults, jobLogEntries, activeLocks };
 }
+export function mapSnapshotJobArtifacts(source) {
+    return {
+        jobResults: Object.fromEntries(source.jobResults),
+        jobLogEntries: Object.fromEntries([...source.jobLogs].map(([id, logs]) => [id, [...logs]])),
+        activeLocks: [...source.activeLocks],
+    };
+}

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

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

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

@@ -33,6 +33,30 @@ export function collectQueueConfigs(queueManager, queueNames) {
     }
     return configs;
 }
+export function mapSnapshotQueueConfigs(queues) {
+    return Object.fromEntries(queues.map((queue) => [
+        queue.name,
+        {
+            paused: queue.paused,
+            rateLimit: queue.rateLimit,
+            concurrencyLimit: queue.concurrencyLimit,
+            concurrencyActive: queue.counts.active,
+            stallConfig: {
+                enabled: queue.stallConfig.enabled,
+                stallInterval: queue.stallConfig.stallInterval,
+                maxStalls: queue.stallConfig.maxStalls,
+                gracePeriod: queue.stallConfig.gracePeriod,
+            },
+            dlqConfig: {
+                autoRetry: queue.dlqConfig.autoRetry,
+                autoRetryInterval: queue.dlqConfig.autoRetryInterval,
+                maxRetries: queue.dlqConfig.maxAutoRetries,
+                maxAge: queue.dlqConfig.maxAge ?? 0,
+                maxEntries: queue.dlqConfig.maxEntries,
+            },
+        },
+    ]));
+}
 export function collectWebhooks(queueManager) {
     try {
         return queueManager.webhookManager.list().map((webhook) => ({
@@ -84,3 +108,22 @@ export function collectTopErrors(queueManager, dlqQueueNames) {
         .map(([message, data]) => ({ message, ...data }))
         .sort((a, b) => b.count - a.count);
 }
+export function mapSnapshotTopErrors(entries) {
+    const errors = new Map();
+    for (const entry of entries) {
+        const message = entry.error ?? entry.reason;
+        const current = errors.get(message);
+        if (!current) {
+            errors.set(message, { count: 1, queue: entry.job.queue, lastSeen: entry.enteredAt });
+            continue;
+        }
+        current.count++;
+        if (entry.enteredAt > current.lastSeen) {
+            current.lastSeen = entry.enteredAt;
+            current.queue = entry.job.queue;
+        }
+    }
+    return [...errors]
+        .map(([message, data]) => ({ message, ...data }))
+        .sort((a, b) => b.count - a.count);
+}

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

@@ -1,5 +1,8 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
 import type { RedactOptions } from '../types/redact';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
+export declare function mapSnapshotJobs(jobs: CloudSnapshotSource['jobs'], redact: RedactOptions): CloudSnapshot['recentJobs'];
+export declare function mapSnapshotDlqEntries(source: CloudSnapshotSource['dlqEntries'], redact: RedactOptions): CloudSnapshot['dlqEntries'];
 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

@@ -87,6 +87,37 @@ function mapJobExtended(job) {
 function mapJobToSnapshot(job, state, redact) {
     return { ...mapJobCore(job, state, redact), ...mapJobExtended(job) };
 }
+export function mapSnapshotJobs(jobs, redact) {
+    return jobs.map(({ job, state }) => mapJobToSnapshot(job, state, redact));
+}
+export function mapSnapshotDlqEntries(source, redact) {
+    return source
+        .map((entry) => ({
+        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,
+        })),
+    }))
+        .sort((left, right) => right.enteredAt - left.enteredAt);
+}
 export function collectLiveJobs(queueManager, queueNames, redact) {
     if (queueNames.length === 0)
         return [];
@@ -94,7 +125,7 @@ export function collectLiveJobs(queueManager, queueNames, redact) {
     for (const name of queueNames) {
         for (const state of ALL_STATES) {
             try {
-                const queueJobs = queueManager.getJobs(name, { state: [state], start: 0, end: 999 });
+                const queueJobs = queueManager.getJobs(name, { state: [state], start: 0, end: 1000 });
                 for (const job of queueJobs)
                     jobs.push(mapJobToSnapshot(job, state, redact));
             }

package/dist/infrastructure/cloud/snapshotCollector.js

@@ -9,63 +9,48 @@ import { throughputTracker } from '../../application/throughputTracker';
 import { latencyTracker } from '../../application/latencyTracker';
 import { getTaskErrorStats } from '../../application/backgroundTasks';
 import { VERSION } from '../../shared/version';
+import { clientStorageStatus } from '../../shared/storageHealth';
 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';
+import { SNAPSHOT_HOST, SNAPSHOT_RUNTIME, enrichFailedJobDurations, mapSnapshotCrons, mapSnapshotJobArtifacts, mapSnapshotWorkers, resolveRedaction, } from './snapshot/collector';
+import { collectWebhooks, collectQueueThroughput, collectDurationHistogram, collectQueueWaitTime, collectQueueRetryRate, collectBacklogVelocity, collectStallDetails, collectPriorityDistribution, mapSnapshotDlqEntries, mapSnapshotJobs, mapSnapshotQueueConfigs, mapSnapshotTopErrors, mapSnapshotWorkerUtilization, } from './snapshotHelpers';
+import { resolveCloudQueueAdapter } from './queueAdapter/registry';
 /** Collect a snapshot. Light data always fresh, heavy data cached between refreshes. */
 export async function collectSnapshot(params) {
     const t0 = performance.now();
     const { queueManager, instanceId, instanceName, startedAt, sequenceId, serverHandles } = params;
     const { redactFields, includeJobData } = resolveRedaction(params);
+    const source = await resolveCloudQueueAdapter(queueManager).readSnapshotSource();
     // ─── MCP operations (drain buffer into snapshot) ───
     const mcpData = serverHandles?.getMcpOperations?.();
     // ─── Light data (O(SHARD_COUNT), every snapshot) ───
-    const stats = queueManager.getStats();
+    const stats = source.stats;
     const memStats = queueManager.getMemoryStats();
-    const workerStats = queueManager.workerManager.getStats();
+    const workerStats = source.workerStats;
     const rates = throughputTracker.getRates();
     const percentiles = latencyTracker.getPercentiles();
     const averages = latencyTracker.getAverages();
-    const storage = queueManager.getStorageStatus();
+    const storage = clientStorageStatus(queueManager.getStorageStatus());
     const mem = process.memoryUsage();
-    const queueNames = queueManager.listQueues();
-    const countsByQueue = queueManager.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: queueManager.isPaused(name),
-            totalCompleted: counts.totalCompleted,
-            totalFailed: counts.totalFailed,
-        };
-    });
-    const crons = collectCrons(queueManager);
+    const queues = source.queues.map(({ name, counts, paused }) => ({ name, ...counts, paused }));
+    const crons = mapSnapshotCrons(source.crons);
     // ─── Full data (every snapshot) ───
     const allQueueNames = queues.map((q) => q.name);
-    const dlqQueues = queues.filter((q) => q.failed > 0);
-    // Live jobs: waiting/active/delayed/failed — bounded by processing capacity
-    const recentJobs = collectLiveJobs(queueManager, allQueueNames, {
+    const recentJobs = mapSnapshotJobs(source.jobs, {
+        redactFields,
+        includeJobData,
+    });
+    const dlqEntries = mapSnapshotDlqEntries(source.dlqEntries, {
         redactFields,
         includeJobData,
     });
-    const dlqEntries = collectDlqEntries(queueManager, dlqQueues.map((q) => q.name), { redactFields, includeJobData });
     enrichFailedJobDurations(recentJobs, dlqEntries);
-    const topErrors = collectTopErrors(queueManager, dlqQueues.map((q) => q.name));
-    const workerDetails = collectWorkerDetails(queueManager, Date.now());
-    const queueConfigs = collectQueueConfigs(queueManager, new Set(queueNames));
+    const topErrors = mapSnapshotTopErrors(source.dlqEntries);
+    const workerDetails = mapSnapshotWorkers(source.workers, Date.now());
+    const queueConfigs = mapSnapshotQueueConfigs(source.queues);
     const webhooks = collectWebhooks(queueManager);
     const s3Backup = serverHandles?.getBackupStatus?.() ?? null;
     const telemetry = queueManager.getCloudTelemetry(allQueueNames);
-    const { jobResults, jobLogEntries, activeLocks } = collectJobArtifacts(queueManager);
+    const { jobResults, jobLogEntries, activeLocks } = mapSnapshotJobArtifacts(source);
     const result = {
         instanceId,
         instanceName,
@@ -126,7 +111,7 @@ export async function collectSnapshot(params) {
         // Analytics
         queueThroughput: collectQueueThroughput(queues),
         durationHistogram: collectDurationHistogram(recentJobs),
-        workerUtilization: collectWorkerUtilization(queueManager),
+        workerUtilization: mapSnapshotWorkerUtilization(source.workers),
         sqliteStats: serverHandles?.getSqliteStats?.() ?? null,
         runtime: SNAPSHOT_RUNTIME,
         queueWaitTime: collectQueueWaitTime(recentJobs),

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

@@ -1,5 +1,5 @@
-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 { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, mapSnapshotWorkerUtilization, } from './snapshot/analytics';
+export { collectQueueConfigs, collectTopErrors, collectWebhooks, mapSnapshotQueueConfigs, mapSnapshotTopErrors, } from './snapshot/config';
+export { collectDlqEntries, collectLiveJobs, mapSnapshotDlqEntries, mapSnapshotJobs, } from './snapshot/jobs';
 export { collectStallDetails } from './snapshot/stalls';
 export type { RedactOptions } from './types/redact';

package/dist/infrastructure/cloud/snapshotHelpers.js

@@ -1,4 +1,4 @@
-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 { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, mapSnapshotWorkerUtilization, } from './snapshot/analytics';
+export { collectQueueConfigs, collectTopErrors, collectWebhooks, mapSnapshotQueueConfigs, mapSnapshotTopErrors, } from './snapshot/config';
+export { collectDlqEntries, collectLiveJobs, mapSnapshotDlqEntries, mapSnapshotJobs, } from './snapshot/jobs';
 export { collectStallDetails } from './snapshot/stalls';