bull

What is bull?

Bull is a Node library that implements a fast and robust queue system based on Redis. It is designed to handle background jobs and message queues, providing features like job scheduling, concurrency control, and job prioritization.

What are bull's main functionalities?

Job Creation

This feature allows you to create and add jobs to a queue. The code sample demonstrates how to create a queue named 'myQueue' and add a job with data { foo: 'bar' } to it.

const Queue = require('bull');
const myQueue = new Queue('myQueue');

myQueue.add({ foo: 'bar' });

Job Processing

This feature allows you to define a processor for the jobs in the queue. The code sample shows how to process jobs in 'myQueue' by logging the job data and performing some processing.

myQueue.process(async (job) => {
  console.log(job.data);
  // Process the job
});

Job Scheduling

This feature allows you to schedule jobs to be processed at a later time. The code sample demonstrates how to add a job to 'myQueue' that will be processed after a delay of 60 seconds.

myQueue.add({ foo: 'bar' }, { delay: 60000 });

Job Prioritization

This feature allows you to set the priority of jobs in the queue. The code sample shows how to add a job with a priority of 1 to 'myQueue'. Higher priority jobs are processed before lower priority ones.

myQueue.add({ foo: 'bar' }, { priority: 1 });

Concurrency Control

This feature allows you to control the number of concurrent job processors. The code sample demonstrates how to process up to 5 jobs concurrently in 'myQueue'.

myQueue.process(5, async (job) => {
  console.log(job.data);
  // Process the job
});

Other packages similar to bull

kue

Kue is another Redis-based priority job queue for Node.js. It provides a similar set of features to Bull, including job creation, processing, scheduling, and prioritization. However, Kue has a more extensive UI for monitoring and managing jobs.

agenda

Agenda is a lightweight job scheduling library for Node.js that uses MongoDB for persistence. It offers features like job scheduling, concurrency control, and job prioritization. Unlike Bull, which uses Redis, Agenda uses MongoDB, making it a good choice for applications already using MongoDB.

bee-queue

Bee-Queue is a simple, fast, and robust job/task queue for Node.js, backed by Redis. It is designed for high performance and low latency, making it suitable for real-time applications. Bee-Queue focuses on simplicity and performance, whereas Bull offers more advanced features and flexibility.

README

Bull Job Manager

A lightweight, robust and fast job processing queue. Designed with stability and atomicity in mind. The API is inspired by Kue.

It uses redis for persistence, so the queue is not lost if the server goes down for any reason.

If you need more features than the ones provided by Bull check Kue but keep in mind this open issue.

Install:

npm install bull

Quick Guide

var Queue = require('bull');

var queue = new Queue('media transcoding', 6379, '127.0.0.1'));

queue.process('video transcode', function(job, done){
  
  // job.data contains the custom data passed when the job was created
  
  // transcode video asynchronously and report progress
  job.progress(42);
  
  // call done when finished
  done();
  
  // or give a error if error
  done(Error('error transcoding'));
  
  // If the job throws an unhandled exception it is also handled correctly
  throw (Error('some unexpected error'));
});

queue.process('audio transcode', function(job, done){
  // transcode audio asynchronously and report progress
  job.progress(42);
  
  // call done when finished
  done();
  
  // or give a error if error
  done(Error('error transcoding'));
  
  // If the job throws an unhandled exception it is also handled correctly
  throw (Error('some unexpected error'));
});

queue.process('image transcode', function(job, done){
  // transcode image asynchronously and report progress
  job.progress(42);
  
  // call done when finished
  done();
  
  // or give a error if error
  done(Error('error transcoding'));
  
  // If the job throws an unhandled exception it is also handled correctly
  throw (Error('some unexpected error'));
});

queue.createJob('video transcode', {video: 'http://example.com/video1.mov'});
queue.createJob('audio transcode', {audio: 'http://example.com/audio1.mp3'});
queue.createJob('image transcode', {image: 'http://example.com/image1.tiff'});

A queue emits also some useful events:

queue.on('completed', function(job){
  // Job completed!
})
.on('failed', function(job, err){
  // Job failed with reason err!
})
.on('progress', function(job, progress){
  // Job progress updated!
})

Queues are cheap, so if you need many of them just create new ones with different names:

var userJohn = new Queue('john');
var userLisa = new Queue('lisa');
.
.
.

Queues are robust and can be run in parallel in several threads or processes without any risk of hazzards or queue corruption. Check this simple example using cluster to parallelize jobs accross processes:

var 
  Queue = require('bull'),
  cluster = require('cluster');

var queue = new Queue("test concurrent queue", 6379, '127.0.0.1');

queue.process('test concurrent job', function(job, jobDone){
  if(cluster.isMaster){
    console.log("Job done in master", job.jobId);
  }else{
    console.log("Job done by worker", cluster.worker.id, job.jobId);
  }
  jobDone();
});

if(cluster.isMaster){
  var numWorkers = 8;
  for (var i = 0; i < numWorkers; i++) {
    cluster.fork();
  }
}

##Documentation

• Queue
• Queue##process
• Queue##createJob
• Job

Reference

###Queue(queueName, redisPort, redisHost, [redisOpts])

This is the Queue constructor. It creates a new Queue that is persisted in Redis. Everytime the same queue is instantiated it tries to process all the old jobs that may exist from a previous unfinished session.

Arguments

    queueName {String} A unique name for this Queue.
    redisPort {Number} A port where redis server is running.
    redisHost {String} A host specified as IP or domain where redis is running.
    redisOptions {Object} Optional options to pass to the redis client.

---

#### Queue##process(jobName, function(job, done))

Defines a processing function for the jobs with the given name.

The callback is called everytime a job in the queue matches the name and provides an instance of the job and a done callback to be called after the job has been completed. If done can be called providing an Error instsance to signal that the job did not complete successfully.

Arguments

    jobName {String} A job type name.
    cb {Function} A callback called for every job of the given name.

---

#### Queue##createJob(jobName, args)

Creates a new job and adds it to the queue. If the queue is empty the job will be executed directly, otherwise it will be placed in the queue and executed as soon as possible.

Arguments

  jobName {String} A job type name.
  args {PlainObject} A plain object with arguments that will be passed
    to the job processing function in job.data.
  returns {Promise} A promise that resolves when the job has been succesfully
    added to the queue (or rejects if some error occured).

---

### Job

A job includes all data needed to perform its execution, as well as the progress method needed to update its progress.

The most important property for the user is Job##data that includes the object that was passed to Queue##createJob, and that is normally used to perform the job.

---

##License

(The MIT License)

Copyright (c) 2013 Manuel Astudillo [e-mail]

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.