@tachybase/plugin-adapter-bullmq 1.3.16 → 1.3.18

package/dist/node_modules/bullmq/dist/esm/classes/worker.js

@@ -8,17 +8,16 @@ import { delay, DELAY_TIME_1, isNotConnectionError, isRedisInstance, } from '../
 import { QueueBase } from './queue-base';
 import { Repeat } from './repeat';
 import { ChildPool } from './child-pool';
-import { Job } from './job';
 import { RedisConnection } from './redis-connection';
 import sandbox from './sandbox';
 import { AsyncFifoQueue } from './async-fifo-queue';
-import { DelayedError, RateLimitError, RATE_LIMIT_ERROR, WaitingChildrenError, } from './errors';
+import { DelayedError, RateLimitError, RATE_LIMIT_ERROR, WaitingChildrenError, WaitingError, UnrecoverableError, } from './errors';
 import { SpanKind, TelemetryAttributes } from '../enums';
 import { JobScheduler } from './job-scheduler';
 // 10 seconds is the maximum time a BZPOPMIN can block.
 const maximumBlockTimeout = 10;
 // 30 seconds is the maximum limit until.
-const maximumLimitUntil = 30000;
+const maximumRateLimitDelay = 30000;
 /**
  *
  * This class represents a worker that is able to process jobs from the queue.
@@ -31,7 +30,7 @@ export class Worker extends QueueBase {
         return new RateLimitError();
     }
     constructor(name, processor, opts, Connection) {
-        super(name, Object.assign(Object.assign({}, opts), { blockingConnection: true }), Connection);
+        super(name, Object.assign(Object.assign({ drainDelay: 5, concurrency: 1, lockDuration: 30000, maxStalledCount: 1, stalledInterval: 30000, autorun: true, runRetryDelay: 15000 }, opts), { blockingConnection: true }), Connection);
         this.abortDelayController = null;
         this.blockUntil = 0;
         this.drained = false;
@@ -39,14 +38,19 @@ export class Worker extends QueueBase {
         this.limitUntil = 0;
         this.waiting = null;
         this.running = false;
+        this.mainLoopRunning = null;
         if (!opts || !opts.connection) {
             throw new Error('Worker requires a connection');
         }
-        this.opts = Object.assign({ drainDelay: 5, concurrency: 1, lockDuration: 30000, maxStalledCount: 1, stalledInterval: 30000, autorun: true, runRetryDelay: 15000 }, this.opts);
-        if (this.opts.stalledInterval <= 0) {
+        if (typeof this.opts.maxStalledCount !== 'number' ||
+            this.opts.maxStalledCount < 0) {
+            throw new Error('maxStalledCount must be greater or equal than 0');
+        }
+        if (typeof this.opts.stalledInterval !== 'number' ||
+            this.opts.stalledInterval <= 0) {
             throw new Error('stalledInterval must be greater than 0');
         }
-        if (this.opts.drainDelay <= 0) {
+        if (typeof this.opts.drainDelay !== 'number' || this.opts.drainDelay <= 0) {
             throw new Error('drainDelay must be greater than 0');
         }
         this.concurrency = this.opts.concurrency;
@@ -105,7 +109,11 @@ export class Worker extends QueueBase {
         const connectionName = this.clientName() + (this.opts.name ? `:w:${this.opts.name}` : '');
         this.blockingConnection = new RedisConnection(isRedisInstance(opts.connection)
             ? opts.connection.duplicate({ connectionName })
-            : Object.assign(Object.assign({}, opts.connection), { connectionName }), false, true, opts.skipVersionCheck);
+            : Object.assign(Object.assign({}, opts.connection), { connectionName }), {
+            shared: false,
+            blocking: true,
+            skipVersionCheck: opts.skipVersionCheck,
+        });
         this.blockingConnection.on('error', error => this.emit('error', error));
         this.blockingConnection.on('ready', () => setTimeout(() => this.emit('ready'), 0));
     }
@@ -180,70 +188,87 @@ export class Worker extends QueueBase {
         }
         try {
             this.running = true;
-            if (this.closing) {
+            if (this.closing || this.paused) {
                 return;
             }
             await this.startStalledCheckTimer();
-            const jobsInProgress = new Set();
-            this.startLockExtenderTimer(jobsInProgress);
-            const asyncFifoQueue = (this.asyncFifoQueue =
-                new AsyncFifoQueue());
-            let tokenPostfix = 0;
             const client = await this.client;
             const bclient = await this.blockingConnection.client;
+            this.mainLoopRunning = this.mainLoop(client, bclient);
+            // We must await here or finally will be called too early.
+            await this.mainLoopRunning;
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async waitForRateLimit() {
+        var _a;
+        const limitUntil = this.limitUntil;
+        if (limitUntil > Date.now()) {
+            (_a = this.abortDelayController) === null || _a === void 0 ? void 0 : _a.abort();
+            this.abortDelayController = new AbortController();
+            const delay = this.getRateLimitDelay(limitUntil - Date.now());
+            await this.delay(delay, this.abortDelayController);
+        }
+    }
+    /**
+     * This is the main loop in BullMQ. Its goals are to fetch jobs from the queue
+     * as efficiently as possible, providing concurrency and minimal unnecessary calls
+     * to Redis.
+     */
+    async mainLoop(client, bclient) {
+        const asyncFifoQueue = new AsyncFifoQueue();
+        const jobsInProgress = new Set();
+        this.startLockExtenderTimer(jobsInProgress);
+        let tokenPostfix = 0;
+        while (!this.closing && !this.paused) {
+            let numTotal = asyncFifoQueue.numTotal();
             /**
-             * This is the main loop in BullMQ. Its goals are to fetch jobs from the queue
-             * as efficiently as possible, providing concurrency and minimal unnecessary calls
-             * to Redis.
+             * This inner loop tries to fetch jobs concurrently, but if we are waiting for a job
+             * to arrive at the queue we should not try to fetch more jobs (as it would be pointless)
              */
-            while (!this.closing) {
-                let numTotal = asyncFifoQueue.numTotal();
-                /**
-                 * This inner loop tries to fetch jobs concurrently, but if we are waiting for a job
-                 * to arrive at the queue we should not try to fetch more jobs (as it would be pointless)
-                 */
-                while (!this.waiting &&
-                    numTotal < this._concurrency &&
-                    (!this.limitUntil || numTotal == 0)) {
-                    const token = `${this.id}:${tokenPostfix++}`;
-                    const fetchedJob = this.retryIfFailed(() => this._getNextJob(client, bclient, token, { block: true }), this.opts.runRetryDelay);
-                    asyncFifoQueue.add(fetchedJob);
-                    numTotal = asyncFifoQueue.numTotal();
-                    if (this.waiting && numTotal > 1) {
-                        // We are waiting for jobs but we have others that we could start processing already
-                        break;
-                    }
-                    // We await here so that we fetch jobs in sequence, this is important to avoid unnecessary calls
-                    // to Redis in high concurrency scenarios.
-                    const job = await fetchedJob;
-                    // No more jobs waiting but we have others that could start processing already
-                    if (!job && numTotal > 1) {
-                        break;
-                    }
-                    // If there are potential jobs to be processed and blockUntil is set, we should exit to avoid waiting
-                    // for processing this job.
-                    if (this.blockUntil) {
-                        break;
-                    }
+            while (!this.closing &&
+                !this.paused &&
+                !this.waiting &&
+                numTotal < this._concurrency &&
+                !this.isRateLimited()) {
+                const token = `${this.id}:${tokenPostfix++}`;
+                const fetchedJob = this.retryIfFailed(() => this._getNextJob(client, bclient, token, { block: true }), this.opts.runRetryDelay);
+                asyncFifoQueue.add(fetchedJob);
+                numTotal = asyncFifoQueue.numTotal();
+                if (this.waiting && numTotal > 1) {
+                    // We are waiting for jobs but we have others that we could start processing already
+                    break;
+                }
+                // We await here so that we fetch jobs in sequence, this is important to avoid unnecessary calls
+                // to Redis in high concurrency scenarios.
+                const job = await fetchedJob;
+                // No more jobs waiting but we have others that could start processing already
+                if (!job && numTotal > 1) {
+                    break;
                 }
-                // Since there can be undefined jobs in the queue (when a job fails or queue is empty)
-                // we iterate until we find a job.
-                let job;
-                do {
-                    job = await asyncFifoQueue.fetch();
-                } while (!job && asyncFifoQueue.numQueued() > 0);
-                if (job) {
-                    const token = job.token;
-                    asyncFifoQueue.add(this.retryIfFailed(() => this.processJob(job, token, () => asyncFifoQueue.numTotal() <= this._concurrency, jobsInProgress), this.opts.runRetryDelay));
+                // If there are potential jobs to be processed and blockUntil is set, we should exit to avoid waiting
+                // for processing this job.
+                if (this.blockUntil) {
+                    break;
                 }
             }
-            this.running = false;
-            return await asyncFifoQueue.waitAll();
-        }
-        catch (error) {
-            this.running = false;
-            throw error;
+            // Since there can be undefined jobs in the queue (when a job fails or queue is empty)
+            // we iterate until we find a job.
+            let job;
+            do {
+                job = await asyncFifoQueue.fetch();
+            } while (!job && asyncFifoQueue.numQueued() > 0);
+            if (job) {
+                const token = job.token;
+                asyncFifoQueue.add(this.retryIfFailed(() => this.processJob(job, token, () => asyncFifoQueue.numTotal() <= this._concurrency, jobsInProgress), this.opts.runRetryDelay));
+            }
+            else if (asyncFifoQueue.numQueued() === 0) {
+                await this.waitForRateLimit();
+            }
         }
+        return asyncFifoQueue.waitAll();
     }
     /**
      * Returns a promise that resolves to the next job in queue.
@@ -265,14 +290,8 @@ export class Worker extends QueueBase {
         }, (_b = (_a = nextJob === null || nextJob === void 0 ? void 0 : nextJob.opts) === null || _a === void 0 ? void 0 : _a.telemetry) === null || _b === void 0 ? void 0 : _b.metadata);
     }
     async _getNextJob(client, bclient, token, { block = true } = {}) {
-        var _a;
         if (this.paused) {
-            if (block) {
-                await this.paused;
-            }
-            else {
-                return;
-            }
+            return;
         }
         if (this.closing) {
             return;
@@ -297,13 +316,9 @@ export class Worker extends QueueBase {
             }
         }
         else {
-            const limitUntil = this.limitUntil;
-            if (limitUntil) {
-                (_a = this.abortDelayController) === null || _a === void 0 ? void 0 : _a.abort();
-                this.abortDelayController = new AbortController();
-                await this.delay(this.getLimitUntil(limitUntil), this.abortDelayController);
+            if (!this.isRateLimited()) {
+                return this.moveToActive(client, token, this.opts.name);
             }
-            return this.moveToActive(client, token, this.opts.name);
         }
     }
     /**
@@ -328,9 +343,12 @@ export class Worker extends QueueBase {
                 0.001
             : 0.002;
     }
+    isRateLimited() {
+        return this.limitUntil > Date.now();
+    }
     async moveToActive(client, token, name) {
-        const [jobData, id, limitUntil, delayUntil] = await this.scripts.moveToActive(client, token, name);
-        this.updateDelays(limitUntil, delayUntil);
+        const [jobData, id, rateLimitDelay, delayUntil] = await this.scripts.moveToActive(client, token, name);
+        this.updateDelays(rateLimitDelay, delayUntil);
         return this.nextJobFromJobData(jobData, id, token);
     }
     async waitForJob(bclient, blockUntil) {
@@ -339,7 +357,7 @@ export class Worker extends QueueBase {
         }
         let timeout;
         try {
-            if (!this.closing && !this.limitUntil) {
+            if (!this.closing && !this.isRateLimited()) {
                 let blockTimeout = this.getBlockTimeout(blockUntil);
                 if (blockTimeout > 0) {
                     blockTimeout = this.blockingConnection.capabilities.canDoubleTimeout
@@ -358,7 +376,13 @@ export class Worker extends QueueBase {
                     if (result) {
                         const [_key, member, score] = result;
                         if (member) {
-                            return parseInt(score);
+                            const newBlockUntil = parseInt(score);
+                            // Use by pro version as rate limited groups could generate lower blockUntil values
+                            // markers only return delays for delayed jobs
+                            if (blockUntil && newBlockUntil > blockUntil) {
+                                return blockUntil;
+                            }
+                            return newBlockUntil;
                         }
                     }
                 }
@@ -401,10 +425,10 @@ export class Worker extends QueueBase {
             return Math.max(opts.drainDelay, this.minimumBlockTimeout);
         }
     }
-    getLimitUntil(limitUntil) {
+    getRateLimitDelay(delay) {
         // We restrict the maximum limit until to 30 second to
         // be able to promote delayed jobs while queue is rate limited
-        return Math.min(limitUntil, maximumLimitUntil);
+        return Math.min(delay, maximumRateLimitDelay);
     }
     /**
      *
@@ -413,8 +437,14 @@ export class Worker extends QueueBase {
     async delay(milliseconds, abortController) {
         await delay(milliseconds || DELAY_TIME_1, abortController);
     }
-    updateDelays(limitUntil = 0, delayUntil = 0) {
-        this.limitUntil = Math.max(limitUntil, 0) || 0;
+    updateDelays(limitDelay = 0, delayUntil = 0) {
+        const clampedLimit = Math.max(limitDelay, 0);
+        if (clampedLimit > 0) {
+            this.limitUntil = Date.now() + clampedLimit;
+        }
+        else {
+            this.limitUntil = 0;
+        }
         this.blockUntil = Math.max(delayUntil, 0) || 0;
     }
     async nextJobFromJobData(jobData, jobId, token) {
@@ -447,9 +477,6 @@ export class Worker extends QueueBase {
     }
     async processJob(job, token, fetchNextCallback = () => true, jobsInProgress) {
         var _a, _b;
-        if (!job || this.closing || this.paused) {
-            return;
-        }
         const srcPropagationMedatada = (_b = (_a = job.opts) === null || _a === void 0 ? void 0 : _a.telemetry) === null || _b === void 0 ? void 0 : _b.metadata;
         return this.trace(SpanKind.CONSUMER, 'process', this.name, async (span) => {
             span === null || span === void 0 ? void 0 : span.setAttributes({
@@ -457,64 +484,20 @@ export class Worker extends QueueBase {
                 [TelemetryAttributes.WorkerName]: this.opts.name,
                 [TelemetryAttributes.JobId]: job.id,
             });
-            const handleCompleted = async (result) => {
-                jobsInProgress.delete(inProgressItem);
-                if (!this.connection.closing) {
-                    const completed = await job.moveToCompleted(result, token, fetchNextCallback() && !(this.closing || this.paused));
-                    this.emit('completed', job, result, 'active');
-                    span === null || span === void 0 ? void 0 : span.addEvent('job completed', {
-                        [TelemetryAttributes.JobResult]: JSON.stringify(result),
-                    });
-                    const [jobData, jobId, limitUntil, delayUntil] = completed || [];
-                    this.updateDelays(limitUntil, delayUntil);
-                    return this.nextJobFromJobData(jobData, jobId, token);
-                }
-            };
-            const handleFailed = async (err) => {
-                jobsInProgress.delete(inProgressItem);
-                if (!this.connection.closing) {
-                    try {
-                        // Check if the job was manually rate-limited
-                        if (err.message == RATE_LIMIT_ERROR) {
-                            this.limitUntil = await this.moveLimitedBackToWait(job, token);
-                            return;
-                        }
-                        if (err instanceof DelayedError ||
-                            err.name == 'DelayedError' ||
-                            err instanceof WaitingChildrenError ||
-                            err.name == 'WaitingChildrenError') {
-                            return;
-                        }
-                        const result = await job.moveToFailed(err, token, true);
-                        this.emit('failed', job, err, 'active');
-                        span === null || span === void 0 ? void 0 : span.addEvent('job failed', {
-                            [TelemetryAttributes.JobFailedReason]: err.message,
-                        });
-                        if (result) {
-                            const [jobData, jobId, limitUntil, delayUntil] = result;
-                            this.updateDelays(limitUntil, delayUntil);
-                            return this.nextJobFromJobData(jobData, jobId, token);
-                        }
-                    }
-                    catch (err) {
-                        this.emit('error', err);
-                        // It probably means that the job has lost the lock before completion
-                        // A worker will (or already has) moved the job back
-                        // to the waiting list (as stalled)
-                        span === null || span === void 0 ? void 0 : span.recordException(err.message);
-                    }
-                }
-            };
             this.emit('active', job, 'waiting');
             const processedOn = Date.now();
             const inProgressItem = { job, ts: processedOn };
             try {
+                if (job.deferredFailure) {
+                    const failed = await this.handleFailed(new UnrecoverableError(job.deferredFailure), job, token, fetchNextCallback, jobsInProgress, inProgressItem, span);
+                    return failed;
+                }
                 jobsInProgress.add(inProgressItem);
                 const result = await this.callProcessJob(job, token);
-                return await handleCompleted(result);
+                return await this.handleCompleted(result, job, token, fetchNextCallback, jobsInProgress, inProgressItem, span);
             }
             catch (err) {
-                const failed = await handleFailed(err);
+                const failed = await this.handleFailed(err, job, token, fetchNextCallback, jobsInProgress, inProgressItem, span);
                 return failed;
             }
             finally {
@@ -525,26 +508,73 @@ export class Worker extends QueueBase {
             }
         }, srcPropagationMedatada);
     }
+    async handleCompleted(result, job, token, fetchNextCallback = () => true, jobsInProgress, inProgressItem, span) {
+        jobsInProgress.delete(inProgressItem);
+        if (!this.connection.closing) {
+            const completed = await job.moveToCompleted(result, token, fetchNextCallback() && !(this.closing || this.paused));
+            this.emit('completed', job, result, 'active');
+            span === null || span === void 0 ? void 0 : span.addEvent('job completed', {
+                [TelemetryAttributes.JobResult]: JSON.stringify(result),
+            });
+            const [jobData, jobId, rateLimitDelay, delayUntil] = completed || [];
+            this.updateDelays(rateLimitDelay, delayUntil);
+            return this.nextJobFromJobData(jobData, jobId, token);
+        }
+    }
+    async handleFailed(err, job, token, fetchNextCallback = () => true, jobsInProgress, inProgressItem, span) {
+        jobsInProgress.delete(inProgressItem);
+        if (!this.connection.closing) {
+            try {
+                // Check if the job was manually rate-limited
+                if (err.message == RATE_LIMIT_ERROR) {
+                    const rateLimitTtl = await this.moveLimitedBackToWait(job, token);
+                    this.limitUntil = rateLimitTtl > 0 ? Date.now() + rateLimitTtl : 0;
+                    return;
+                }
+                if (err instanceof DelayedError ||
+                    err.name == 'DelayedError' ||
+                    err instanceof WaitingError ||
+                    err.name == 'WaitingError' ||
+                    err instanceof WaitingChildrenError ||
+                    err.name == 'WaitingChildrenError') {
+                    return;
+                }
+                const result = await job.moveToFailed(err, token, fetchNextCallback() && !(this.closing || this.paused));
+                this.emit('failed', job, err, 'active');
+                span === null || span === void 0 ? void 0 : span.addEvent('job failed', {
+                    [TelemetryAttributes.JobFailedReason]: err.message,
+                });
+                if (result) {
+                    const [jobData, jobId, rateLimitDelay, delayUntil] = result;
+                    this.updateDelays(rateLimitDelay, delayUntil);
+                    return this.nextJobFromJobData(jobData, jobId, token);
+                }
+            }
+            catch (err) {
+                this.emit('error', err);
+                // It probably means that the job has lost the lock before completion
+                // A worker will (or already has) moved the job back
+                // to the waiting list (as stalled)
+                span === null || span === void 0 ? void 0 : span.recordException(err.message);
+            }
+        }
+    }
     /**
      *
      * Pauses the processing of this queue only for this worker.
      */
     async pause(doNotWaitActive) {
         await this.trace(SpanKind.INTERNAL, 'pause', this.name, async (span) => {
+            var _a;
             span === null || span === void 0 ? void 0 : span.setAttributes({
                 [TelemetryAttributes.WorkerId]: this.id,
                 [TelemetryAttributes.WorkerName]: this.opts.name,
                 [TelemetryAttributes.WorkerDoNotWaitActive]: doNotWaitActive,
             });
             if (!this.paused) {
-                this.paused = new Promise(resolve => {
-                    this.resumeWorker = function () {
-                        resolve();
-                        this.paused = null; // Allow pause to be checked externally for paused state.
-                        this.resumeWorker = null;
-                    };
-                });
+                this.paused = true;
                 await (!doNotWaitActive && this.whenCurrentJobsFinished());
+                (_a = this.stalledCheckStopper) === null || _a === void 0 ? void 0 : _a.call(this);
                 this.emit('paused');
             }
         });
@@ -554,13 +584,16 @@ export class Worker extends QueueBase {
      * Resumes processing of this worker (if paused).
      */
     resume() {
-        if (this.resumeWorker) {
+        if (!this.running) {
             this.trace(SpanKind.INTERNAL, 'resume', this.name, span => {
                 span === null || span === void 0 ? void 0 : span.setAttributes({
                     [TelemetryAttributes.WorkerId]: this.id,
                     [TelemetryAttributes.WorkerName]: this.opts.name,
                 });
-                this.resumeWorker();
+                this.paused = false;
+                if (this.processFn) {
+                    this.run();
+                }
                 this.emit('resumed');
             });
         }
@@ -599,17 +632,16 @@ export class Worker extends QueueBase {
         if (this.closing) {
             return this.closing;
         }
-        await this.trace(SpanKind.INTERNAL, 'close', this.name, async (span) => {
-            span === null || span === void 0 ? void 0 : span.setAttributes({
-                [TelemetryAttributes.WorkerId]: this.id,
-                [TelemetryAttributes.WorkerName]: this.opts.name,
-                [TelemetryAttributes.WorkerForceClose]: force,
-            });
-            this.closing = (async () => {
+        this.closing = (async () => {
+            await this.trace(SpanKind.INTERNAL, 'close', this.name, async (span) => {
                 var _a, _b;
+                span === null || span === void 0 ? void 0 : span.setAttributes({
+                    [TelemetryAttributes.WorkerId]: this.id,
+                    [TelemetryAttributes.WorkerName]: this.opts.name,
+                    [TelemetryAttributes.WorkerForceClose]: force,
+                });
                 this.emit('closing', 'closing queue');
                 (_a = this.abortDelayController) === null || _a === void 0 ? void 0 : _a.abort();
-                this.resume();
                 // Define the async cleanup functions
                 const asyncCleanups = [
                     () => {
@@ -632,9 +664,9 @@ export class Worker extends QueueBase {
                 (_b = this.stalledCheckStopper) === null || _b === void 0 ? void 0 : _b.call(this);
                 this.closed = true;
                 this.emit('closed');
-            })();
-            return await this.closing;
-        });
+            });
+        })();
+        return await this.closing;
     }
     /**
      *
@@ -664,7 +696,7 @@ export class Worker extends QueueBase {
         }
     }
     async stalledChecker() {
-        while (!this.closing) {
+        while (!(this.closing || this.paused)) {
             try {
                 await this.checkConnectionError(() => this.moveStalledJobsToWait());
             }
@@ -728,8 +760,8 @@ export class Worker extends QueueBase {
         else {
             reconnect = false;
         }
-        if (this.asyncFifoQueue) {
-            await this.asyncFifoQueue.waitAll();
+        if (this.mainLoopRunning) {
+            await this.mainLoopRunning;
         }
         reconnect && (await this.blockingConnection.reconnect());
     }
@@ -771,13 +803,11 @@ export class Worker extends QueueBase {
     }
     async moveStalledJobsToWait() {
         await this.trace(SpanKind.INTERNAL, 'moveStalledJobsToWait', this.name, async (span) => {
-            const chunkSize = 50;
-            const [failed, stalled] = await this.scripts.moveStalledJobsToWait();
+            const stalled = await this.scripts.moveStalledJobsToWait();
             span === null || span === void 0 ? void 0 : span.setAttributes({
                 [TelemetryAttributes.WorkerId]: this.id,
                 [TelemetryAttributes.WorkerName]: this.opts.name,
                 [TelemetryAttributes.WorkerStalledJobs]: stalled,
-                [TelemetryAttributes.WorkerFailedJobs]: failed,
             });
             stalled.forEach((jobId) => {
                 span === null || span === void 0 ? void 0 : span.addEvent('job stalled', {
@@ -785,31 +815,10 @@ export class Worker extends QueueBase {
                 });
                 this.emit('stalled', jobId, 'active');
             });
-            // Todo: check if there any listeners on failed event
-            const jobPromises = [];
-            for (let i = 0; i < failed.length; i++) {
-                jobPromises.push(Job.fromId(this, failed[i]));
-                if ((i + 1) % chunkSize === 0) {
-                    this.notifyFailedJobs(await Promise.all(jobPromises));
-                    jobPromises.length = 0;
-                }
-            }
-            this.notifyFailedJobs(await Promise.all(jobPromises));
-        });
-    }
-    notifyFailedJobs(failedJobs, span) {
-        const failedReason = 'job stalled more than allowable limit';
-        failedJobs.forEach((job) => {
-            span === null || span === void 0 ? void 0 : span.addEvent('job failed', {
-                [TelemetryAttributes.JobId]: job.id,
-                [TelemetryAttributes.JobName]: job.name,
-                [TelemetryAttributes.JobFailedReason]: failedReason,
-            });
-            this.emit('failed', job, new Error(failedReason), 'active');
         });
     }
     moveLimitedBackToWait(job, token) {
-        return this.scripts.moveJobFromActiveToWait(job.id, token);
+        return job.moveToWait(token);
     }
 }
 //# sourceMappingURL=worker.js.map

package/dist/node_modules/bullmq/dist/esm/commands/addDelayedJob-6.lua

@@ -26,7 +26,7 @@
             [8]  parent? {id, queueKey}
             [9]  repeat job key
             [10] deduplication key
-            
+
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
 
@@ -56,9 +56,8 @@ local deduplicationKey = args[10]
 local parentData
 
 -- Includes
---- @include "includes/addDelayMarkerIfNeeded"
+--- @include "includes/addDelayedJob"
 --- @include "includes/deduplicateJob"
---- @include "includes/getDelayedScore"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/handleDuplicatedJob"
 --- @include "includes/storeJob"
@@ -90,26 +89,16 @@ else
     end
 end
 
-local deduplicationJobId = deduplicateJob(args[1], opts['de'],
-  jobId, deduplicationKey, eventsKey, maxEvents)
+local deduplicationJobId = deduplicateJob(opts['de'], jobId, delayedKey, deduplicationKey,
+  eventsKey, maxEvents, args[1])
 if deduplicationJobId then
   return deduplicationJobId
 end
 
--- Store the job.
 local delay, priority = storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2],
-                                 opts, timestamp, parentKey, parentData,
-                                 repeatJobKey)
-
-local score, delayedTimestamp = getDelayedScore(delayedKey, timestamp, tonumber(delay))
-
-rcall("ZADD", delayedKey, score, jobId)
-rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "delayed",
-      "jobId", jobId, "delay", delayedTimestamp)
+    opts, timestamp, parentKey, parentData, repeatJobKey)
 
--- mark that a delayed job is available
-local markerKey = KEYS[1]
-addDelayMarkerIfNeeded(markerKey, delayedKey)
+addDelayedJob(jobId, delayedKey, eventsKey, timestamp, maxEvents, KEYS[1], delay)
 
 -- Check if this job is a child of another job, if so add it to the parents dependencies
 if parentDependenciesKey ~= nil then