bunqueue 2.8.54 → 2.8.57

package/dist/application/queue-manager/services.js

@@ -0,0 +1,80 @@
+import { shardIndex } from '../../shared/hash';
+import { QueueManagerObservability } from './observability';
+export class QueueManagerServices extends QueueManagerObservability {
+    addCron(input) {
+        if (input.preventOverlap) {
+            this.removeOrphanedCronJob(input.queue, input.uniqueKey ?? `cron:${input.name}`);
+        }
+        const cron = this.cronScheduler.add(input);
+        this.storage?.saveCron(cron);
+        return cron;
+    }
+    removeOrphanedCronJob(queue, uniqueKey) {
+        const index = shardIndex(queue);
+        const shard = this.shards[index];
+        const entry = shard.getUniqueKeyEntry(queue, uniqueKey);
+        if (!entry)
+            return;
+        const targetId = entry.jobId;
+        if (this.jobIndex.get(targetId)?.type !== 'queue')
+            return;
+        const job = shard.getQueue(queue).remove(targetId);
+        if (!job)
+            return;
+        shard.decrementQueued(targetId);
+        shard.releaseUniqueKey(queue, uniqueKey);
+        this.jobIndex.delete(targetId);
+        this.storage?.deleteJob(targetId);
+    }
+    removeCron(name) {
+        const removed = this.cronScheduler.remove(name);
+        if (removed)
+            this.storage?.deleteCron(name);
+        return removed;
+    }
+    getCron(name) {
+        return this.cronScheduler.get(name);
+    }
+    listCrons() {
+        return this.cronScheduler.list();
+    }
+    setDashboardEmit(fn) {
+        this.dashboardEmit = fn;
+        this.cronScheduler.setDashboardEmit(fn);
+        this.webhookManager.setDashboardEmit(fn);
+        this.workerManager.setDashboardEmit(fn);
+        if (this.recoveryStats) {
+            fn('server:recovered', this.recoveryStats);
+            this.recoveryStats = null;
+        }
+    }
+    emitDashboardEvent(event, data) {
+        this.dashboardEmit?.(event, data);
+    }
+    subscribe(callback) {
+        return this.eventsManager.subscribe(callback);
+    }
+    waitForJobCompletion(jobId, timeoutMs) {
+        return this.eventsManager.waitForJobCompletion(jobId, timeoutMs);
+    }
+    registerWorker(name, queues, concurrency, options) {
+        const worker = this.workerManager.register(name, queues, concurrency, options);
+        this.dashboardEmit?.('worker:connected', {
+            workerId: worker.id,
+            name: worker.name,
+            queues: worker.queues,
+            hostname: worker.hostname,
+            pid: worker.pid,
+        });
+        return worker;
+    }
+    unregisterWorker(workerId) {
+        const removed = this.workerManager.unregister(workerId);
+        if (removed)
+            this.dashboardEmit?.('worker:disconnected', { workerId });
+        return removed;
+    }
+    unregisterWorkersByClientId(clientId) {
+        return this.workerManager.unregisterByClientId(clientId);
+    }
+}

package/dist/application/queue-manager/state.d.ts

@@ -0,0 +1,92 @@
+import type { Job, JobId, JobLock } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { JobLogEntry } from '../../domain/types/worker';
+import { Shard } from '../../domain/queue/shard';
+import { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import { RWLock } from '../../shared/lock';
+import { BoundedMap, BoundedSet, LRUMap } from '../../shared/lru';
+import { WebhookManager } from '../webhookManager';
+import { WorkerManager } from '../workerManager';
+import { EventsManager } from '../eventsManager';
+import { type MonitoringState } from '../monitoringChecks';
+import type { OperationalMetrics } from '../metricsExporter';
+import { DEFAULT_CONFIG, type QueueManagerConfig } from '../types';
+import * as bgTasks from '../backgroundTasks';
+import { ContextFactory } from '../contextFactory';
+import { DependencyResultTracker } from '../dependencyResultTracker';
+import { DependencyCompletionTracker } from '../dependencyCompletions';
+import { JobTimeoutScheduler } from '../background/timeouts';
+import type { RetiredTimeoutGeneration } from '../types/background';
+import { QueueTelemetryJournal } from '../queueTelemetryJournal';
+export type { QueueManagerConfig };
+export declare abstract class QueueManagerState {
+    protected readonly config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    protected readonly storage: SqliteStorage | null;
+    protected readonly shards: Shard[];
+    protected readonly shardLocks: RWLock[];
+    protected readonly customIdLock: RWLock;
+    protected readonly processingShards: Map<JobId, Job>[];
+    protected readonly processingLocks: RWLock[];
+    protected readonly jobIndex: Map<JobId, JobLocation>;
+    protected readonly completedJobs: BoundedSet<JobId>;
+    protected readonly completedJobsData: BoundedMap<JobId, Job>;
+    protected readonly depCompletions: DependencyCompletionTracker;
+    protected readonly timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    protected readonly retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+    protected readonly retiredCronLeaseTokens: BoundedMap<JobId, string>;
+    protected readonly timeoutScheduler: JobTimeoutScheduler;
+    protected readonly jobResults: LRUMap<JobId, unknown>;
+    protected readonly dependencyResults: DependencyResultTracker;
+    protected readonly customIdMap: LRUMap<string, JobId>;
+    protected readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    protected readonly pendingDepChecks: Set<JobId>;
+    protected readonly stalledCandidates: Set<JobId>;
+    protected depFlushScheduled: boolean;
+    protected depFlushRunning: boolean;
+    protected readonly jobLocks: Map<JobId, JobLock>;
+    protected readonly clientJobs: Map<string, Set<JobId>>;
+    protected readonly repeatChain: Map<JobId, JobId>;
+    protected readonly failedChildrenValues: Map<JobId, Record<string, string>>;
+    protected readonly ignoredChildrenFailures: Map<JobId, Record<string, string>>;
+    protected readonly cronScheduler: CronScheduler;
+    readonly webhookManager: WebhookManager;
+    readonly workerManager: WorkerManager;
+    protected readonly eventsManager: EventsManager;
+    protected dashboardEmit: ((event: string, data: Record<string, unknown>) => void) | null;
+    protected recoveryStats: {
+        queues: number;
+        jobs: number;
+    } | null;
+    protected readonly maxLogsPerJob = 100;
+    protected readonly metrics: {
+        totalPushed: {
+            value: bigint;
+        };
+        totalPulled: {
+            value: bigint;
+        };
+        totalCompleted: {
+            value: bigint;
+        };
+        totalFailed: {
+            value: bigint;
+        };
+    };
+    protected operationalMetricsProvider: (() => OperationalMetrics) | null;
+    protected readonly perQueueMetrics: LRUMap<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    protected readonly telemetryJournal: QueueTelemetryJournal;
+    protected readonly startTime: number;
+    protected readonly backgroundTaskHandles: bgTasks.BackgroundTaskHandles | null;
+    protected readonly queueNamesCache: Set<string>;
+    protected readonly monitoringState: MonitoringState;
+    protected readonly contextFactory: ContextFactory;
+    protected scheduleJobTimeout(job: Job): void;
+    protected syncJobTimeout(jobId: JobId): void;
+    constructor(config?: QueueManagerConfig);
+}

package/dist/application/queue-manager/state.js

@@ -0,0 +1,144 @@
+import { Shard } from '../../domain/queue/shard';
+import { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import { RWLock } from '../../shared/lock';
+import { SHARD_COUNT } from '../../shared/hash';
+import { BoundedMap, BoundedSet, LRUMap } from '../../shared/lru';
+import { WebhookManager } from '../webhookManager';
+import { WorkerManager } from '../workerManager';
+import { EventsManager } from '../eventsManager';
+import { createMonitoringState } from '../monitoringChecks';
+import { DEFAULT_CONFIG } from '../types';
+import * as bgTasks from '../backgroundTasks';
+import { ContextFactory } from '../contextFactory';
+import { DependencyResultTracker } from '../dependencyResultTracker';
+import { recoverFlowFailures } from '../flowFailureRecovery';
+import { DependencyCompletionTracker } from '../dependencyCompletions';
+import { JobTimeoutScheduler } from '../background/timeouts';
+import { QueueTelemetryJournal } from '../queueTelemetryJournal';
+import { createContextCallbacks, createContextDependencies, managerRuntime } from './context';
+export class QueueManagerState {
+    config;
+    storage;
+    shards = [];
+    shardLocks = [];
+    customIdLock = new RWLock();
+    processingShards = [];
+    processingLocks = [];
+    jobIndex = new Map();
+    completedJobs;
+    completedJobsData;
+    depCompletions;
+    timedOutJobs;
+    retiredTimeoutLeaseTokens;
+    retiredCronLeaseTokens;
+    timeoutScheduler = new JobTimeoutScheduler();
+    jobResults;
+    dependencyResults = new DependencyResultTracker();
+    customIdMap;
+    jobLogs;
+    pendingDepChecks = new Set();
+    stalledCandidates = new Set();
+    depFlushScheduled = false;
+    depFlushRunning = false;
+    jobLocks = new Map();
+    clientJobs = new Map();
+    repeatChain = new Map();
+    failedChildrenValues = new Map();
+    ignoredChildrenFailures = new Map();
+    cronScheduler;
+    webhookManager;
+    workerManager;
+    eventsManager;
+    dashboardEmit = null;
+    recoveryStats = null;
+    maxLogsPerJob = 100;
+    metrics = {
+        totalPushed: { value: 0n },
+        totalPulled: { value: 0n },
+        totalCompleted: { value: 0n },
+        totalFailed: { value: 0n },
+    };
+    operationalMetricsProvider = null;
+    perQueueMetrics;
+    telemetryJournal;
+    startTime = Date.now();
+    backgroundTaskHandles;
+    queueNamesCache = new Set();
+    monitoringState = createMonitoringState();
+    contextFactory;
+    scheduleJobTimeout(job) {
+        this.timeoutScheduler.schedule(job);
+    }
+    syncJobTimeout(jobId) {
+        const location = this.jobIndex.get(jobId);
+        const job = location?.type === 'processing'
+            ? (this.processingShards[location.shardIdx].get(jobId) ?? null)
+            : null;
+        if (job)
+            this.timeoutScheduler.schedule(job);
+        else
+            this.timeoutScheduler.cancel(jobId);
+    }
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.storage = config.dataPath ? new SqliteStorage({ path: config.dataPath }) : null;
+        this.telemetryJournal = new QueueTelemetryJournal(this.storage, this.config.maxQueueEvents, this.config.maxMetricDataPoints);
+        this.completedJobsData = new BoundedMap(this.config.maxCompletedJobs);
+        this.completedJobs = new BoundedSet(this.config.maxCompletedJobs, (id) => {
+            this.jobIndex.delete(id);
+            this.completedJobsData.delete(id);
+        });
+        this.depCompletions = new DependencyCompletionTracker(this.config.maxCompletedJobs, (id) => {
+            this.storage?.deleteDependencyCompletion(id);
+        });
+        this.timedOutJobs = new BoundedMap(this.config.maxCompletedJobs);
+        this.retiredTimeoutLeaseTokens = new BoundedMap(this.config.maxCompletedJobs);
+        this.retiredCronLeaseTokens = new BoundedMap(this.config.maxCompletedJobs);
+        this.perQueueMetrics = new LRUMap(this.config.maxCustomIds);
+        this.jobResults = new LRUMap(this.config.maxJobResults);
+        this.customIdMap = new LRUMap(this.config.maxCustomIds);
+        this.jobLogs = new LRUMap(this.config.maxJobLogs);
+        const runtime = managerRuntime(this);
+        for (let index = 0; index < SHARD_COUNT; index++) {
+            this.shards.push(new Shard({ onDlqEvicted: (entry) => runtime.onDlqEvicted(entry) }));
+            this.shardLocks.push(new RWLock());
+            this.processingShards.push(new Map());
+            this.processingLocks.push(new RWLock());
+        }
+        this.cronScheduler = new CronScheduler();
+        this.cronScheduler.setPushCallback(async (queue, input) => {
+            await runtime.push(queue, input);
+        });
+        if (this.storage) {
+            const storage = this.storage;
+            this.cronScheduler.setPersistCallback((name, executions, nextRun) => {
+                storage.updateCron(name, executions, nextRun);
+            });
+        }
+        this.webhookManager = new WebhookManager({ validateUrls: config.validateWebhookUrls });
+        this.workerManager = new WorkerManager();
+        this.cronScheduler.setWorkerCheckCallback((queue) => this.workerManager.getForQueue(queue).length > 0);
+        this.eventsManager = new EventsManager(this.webhookManager);
+        this.eventsManager.subscribe((event) => this.telemetryJournal.record(event));
+        this.contextFactory = new ContextFactory(createContextDependencies(managerRuntime(this)), createContextCallbacks(runtime));
+        bgTasks.recover(this.contextFactory.getBackgroundContext());
+        if (this.storage) {
+            recoverFlowFailures({
+                storage: this.storage,
+                shards: this.shards,
+                jobIndex: this.jobIndex,
+                completedJobs: this.completedJobs,
+                depCompletions: this.depCompletions,
+                maxDependencyCompletions: this.config.maxCompletedJobs,
+                dependencyResults: this.dependencyResults,
+                failedChildrenValues: this.failedChildrenValues,
+                ignoredChildrenFailures: this.ignoredChildrenFailures,
+            });
+        }
+        this.recoveryStats = { queues: this.queueNamesCache.size, jobs: this.jobIndex.size };
+        if (this.storage)
+            this.cronScheduler.load(this.storage.loadCronJobs());
+        this.backgroundTaskHandles = bgTasks.startBackgroundTasks(this.contextFactory.getBackgroundContext(), this.cronScheduler);
+    }
+}

package/dist/application/queue-manager/stats.d.ts

@@ -0,0 +1,28 @@
+import * as statsMgr from '../statsManager';
+import { QueueManagerJobManagement } from './job-management';
+export declare class QueueManagerStats extends QueueManagerJobManagement {
+    getStats(): statsMgr.QueueStats;
+    getQueuesSummary(): Array<{
+        name: string;
+        paused: boolean;
+        counts: {
+            waiting: number;
+            prioritized: number;
+            active: number;
+            completed: number;
+            failed: number;
+            delayed: number;
+        };
+    }>;
+    getAllQueueJobCounts(): Map<string, statsMgr.QueueJobCounts>;
+    getQueueJobCountsBatch(queueNames: Iterable<string>): Map<string, statsMgr.QueueJobCounts>;
+    getQueueJobCounts(queueName: string): statsMgr.QueueJobCounts;
+    getMemoryStats(): statsMgr.MemoryStats;
+    getStorageStatus(): {
+        diskFull: boolean;
+        error: string | null;
+        since: number | null;
+    };
+    flushPersistence(): number;
+    compactMemory(): void;
+}

package/dist/application/queue-manager/stats.js

@@ -0,0 +1,52 @@
+import * as statsMgr from '../statsManager';
+import { QueueManagerJobManagement } from './job-management';
+export class QueueManagerStats extends QueueManagerJobManagement {
+    getStats() {
+        return statsMgr.getStats(this.contextFactory.getStatsContext(), this.cronScheduler);
+    }
+    getQueuesSummary() {
+        const queues = this.listQueues();
+        const result = [];
+        const countsByQueue = statsMgr.getAllQueueJobCounts(queues, this.contextFactory.getStatsContext());
+        for (const name of queues) {
+            const counts = countsByQueue.get(name);
+            if (!counts)
+                continue;
+            result.push({
+                name,
+                paused: this.isPaused(name),
+                counts: {
+                    waiting: counts.waiting,
+                    prioritized: counts.prioritized,
+                    active: counts.active,
+                    completed: counts.completed,
+                    failed: counts.failed,
+                    delayed: counts.delayed,
+                },
+            });
+        }
+        return result;
+    }
+    getAllQueueJobCounts() {
+        return this.getQueueJobCountsBatch(this.queueNamesCache);
+    }
+    getQueueJobCountsBatch(queueNames) {
+        return statsMgr.getAllQueueJobCounts(queueNames, this.contextFactory.getStatsContext());
+    }
+    getQueueJobCounts(queueName) {
+        return statsMgr.getQueueJobCounts(queueName, this.contextFactory.getStatsContext());
+    }
+    getMemoryStats() {
+        return statsMgr.getMemoryStats(this.contextFactory.getStatsContext());
+    }
+    getStorageStatus() {
+        return this.storage?.getDiskFullStatus() ?? { diskFull: false, error: null, since: null };
+    }
+    flushPersistence() {
+        return this.storage?.flushWriteBuffer() ?? 0;
+    }
+    compactMemory() {
+        statsMgr.compactMemory(this.contextFactory.getStatsContext());
+        this.dashboardEmit?.('memory:compacted', {});
+    }
+}