Obliterate not working properly

[Theo-Le-Donne]

Description

I try to implement the obliterate method but i get a strange behavior.

Basically i ave a batch of jobs that are used to periodically execute requests, and i want a "reset" method, that removes all jobs and recreate them. I was doing this "manually" using some pause(), empty(), moveToCompleted(), but obliterate seems to be the perfect fit.

Problem is that obliterate seems to miss failed and delayed jobs.

Here are the stats (bull-repl) after 4 "resets".

As you can see, each "reset" adds ~1400 delayed jobs. But the delayed count increase at each "reset", and failed jobs are not removed.

Anyone seen this behavior ?

Simplified code

const initQueue:  QueueInit = (): Queue<TQueuePayload> => {
  const queue: Queue<TQueuePayload> = new Bull(CACHE_QUEUE_NAME, {
      redis: QUEUE_REDIS_URL,
  });

  /**
   * @description Cleans the queue from running and waiting jobs, and inits all the cache search jobs
   * @returns {Promise<void>}
   */
  queue.reset = async (): Promise<void> => {
      await queue.obliterate({ force: true });
      await queue.resume();

      // In a for loop
      array.push(queue.add(payload, 
        {attempts: 1,
          lifo: true,
          removeOnComplete: true,
          removeOnFail: true,
          timeout: 30000, 
          delay: someDelay
       })
      )

      await Promise.all(array);
  }

return queue;
}

// In a script later
const queue = initQueue();
await queue.reset()

Bull version

3.22.1

[manast]

thanks for the report. I cannot see anything that would cause such a behaviour. Would you mind to write a test case that demonstrates that this actually happens? for example, this is one test for the obliterate function:

  it('should obliterate a queue with jobs in different statuses', async () => {
    await queue.add({ foo: 'bar' });
    await queue.add({ foo: 'bar2' });
    await queue.add({ foo: 'bar3' }, { delay: 5000 });
    const job = await queue.add({ qux: 'baz' });

    let first = true;
    queue.process(async () => {
      if (first) {
        first = false;
        throw new Error('failed first');
      }
      return delay(250);
    });

    await job.finished();

    await queue.obliterate();
    const client = await queue.client;
    const keys = await client.keys(`bull:${queue.name}*`);
    expect(keys.length).to.be.eql(0);
  });

[Theo-Le-Donne]

Thanks for the reply !
Here is a failing test running on a on higher number of jobs:

  it('should obliterate a queue with high number of jobs in different statuses', async () => {
    await queue.add({ foo: 'bar' });
    await queue.add({ foo: 'bar2' });
    const arr = [];
    for (let i = 0; i < 2000; i++) {
      arr.push(queue.add({ foo: `barLoop${i}` }, { delay: 10000 }));
    }
    await Promise.all(arr);
    await queue.add({ foo: 'bar3' }, { delay: 5000 });
    const job = await queue.add({ qux: 'baz' });

    let first = true;
    queue.process(async () => {
      if (first) {
        first = false;
        throw new Error('failed first');
      }
      return delay(250);
    });

    await job.finished();

    await queue.obliterate();
    const client = await queue.client;
    const keys = await client.keys(`bull:${queue.name}*`);
    expect(keys.length).to.be.eql(0);
  });

[rimiti]

We've the same issue. This function doesn't work properly when you queues have a lot of jobs.

[Theo-Le-Donne]

Also fyi i added a PR on DefinitelyTyped to add type definition for obliterate()

DefinitelyTyped/DefinitelyTyped#52510

[manast]

I found the issue, I am working on a fix

[Theo-Le-Donne]

Great ! Found it too i think, maxCount at 1000

[Theo-Le-Donne]

I found the issue, I am working on a fix

Hey, just wanted to know, should we expect a fix soon or do i focus on a workaround for now ? Thanks

[manast]

🎉 This issue has been resolved in version 3.22.2 🎉

The release is available on:

• npm package (@latest dist-tag)
• GitHub release

Your semantic-release bot 📦🚀