Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

redis-smq

Package Overview
Dependencies
Maintainers
1
Versions
150
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

redis-smq

A simple high-performance Redis message queue for Node.js.

  • 7.2.3
  • latest
  • Source
  • npm
  • Socket score

Version published
Weekly downloads
2.6K
increased by16.71%
Maintainers
1
Weekly downloads
 
Created
Source

RedisSMQ

A simple high-performance Redis message queue for Node.js.

RedisSMQ

Tests Code quality Coverage Status NPM version NPM downloads

RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing them asynchronously with consumers. Backed by Redis, it allows scaling up your application with ease of use.

Features

RedisSMQ Use Case: Multi-Queue Producers & Multi-Queue Consumers

 

RedisSMQ Overview

Table of Content

  1. What's new?
  2. Installation
  3. Configuration
  4. Usage
    1. Basics
      1. Message
      2. Producer
      3. Consumer
        1. Message Acknowledgement
    2. Advanced Topics
      1. Scheduling Messages
      2. Message Exchanges
      3. Queue Rate Limiting
      4. Multiplexing
      5. Message Manager
      6. Queue Manager
      7. HTTP API
      8. Web UI
      9. Logs
  5. RedisSMQ Architecture
  6. Performance
  7. Contributing
  8. License

What's new?

2023.01.06

:rocket: RedisSMQ v7.2 is released! Before this release RedisSMQ supported both LIFO queues and Priority queues. With this new release, RedisSMQ now provides FIFO queues as a third option that completes the list of supported queue types. For more details see Queues.

Installation

npm install redis-smq-common redis-smq --save

Considerations:

  • Minimal Node.js version is >= 14 (RedisSMQ is tested under current active LTS and maintenance LTS Node.js releases).
  • Minimal Redis server version is 2.6.12 (RedisSMQ is tested under Redis v2.6, v3, v4, v5, and v6).

Configuration

See Configuration for more details.

Usage

Basics

RedisSMQ provides 3 classes in order to work with the message queue: Message, Producer, and Consumer.

Producers and consumers exchange data using one or multiple queues that may be created using the QueueManager.

A queue is responsible for holding messages which are produced by producers and are delivered to consumers.

const { QueueManager } = require('redis-smq');
const { EQueueType } = require('redis-smq/dist/types');
const config = require('./config')

QueueManager.createInstance(config, (err, queueManager) => {
  if (err) console.log(err);
  // Creating a LIFO queue
  else queueManager.queue.save('test_queue', EQueueType.LIFO_QUEUE, (err) => console.log(err));
})

See Queues for more details.

Message

Message class is responsible for creating messages that may be published.

A message can carry your application data, sometimes referred to as message payload, which may be delivered to a consumer to be processed asynchronously.

The message payload can be of any valid JSON data type. It may be a simple text message like Hello world or a complex data type like {hello: 'world'}.

const { Message } = require('redis-smq');
const message = new Message();
message
    .setBody({hello: 'world'})
    .setTTL(3600000)
    .setRetryThreshold(5);

The Message class provides many methods for setting up different message parameters such as message body, message priority, message TTL, etc.

See Message Reference for more details.

Producer

A Producer instance allows to publish a message to a queue.

You can use a single Producer instance to produce messages, including messages with priority, to one or multiple queues.

Before publishing a message do not forget to set an exchange for the message using setQueue(), setTopic(), or setFanOut(). Otherwise, an error will be returned. See Message Exchanges for more details.

'use strict';
const {Message, Producer} = require('redis-smq');

const producer = new Producer();
producer.run((err) => {
   if (err) throw err;
   const message = new Message();
   message
           .setBody({hello: 'world'})
           .setTTL(3600000) // message expiration (in millis)
           .setQueue('test_queue'); // setting up a direct exchange 
   message.getId() // null
   producer.produce(message, (err) => {
      if (err) console.log(err);
      else {
         const msgId = message.getId(); // string
         console.log('Successfully produced. Message ID is ', msgId);
      }
   });
})

Starting with v7.0.6, before producing messages you need first to run your producer instance.

See Producer Reference for more details.

Consumer

A Consumer instance can be used to receive and consume messages from one or multiple queues.

To consume messages from a queue, the Consumer class provides the consume() method which allows to register a message handler.

A message handler is a function that receives a delivered message from a given queue.

Message handlers can be registered at any time, before or after a consumer has been started.

In contrast to producers, consumers are not automatically started upon creation. To start a consumer use the run() method.

To stop consuming messages from a queue and to remove the associated message handler from your consumer, use the cancel() method.

To shut down completely your consumer and tear down all message handlers, use the shutdown() method.

'use strict';

const { Consumer } = require('redis-smq');

const consumer = new Consumer();

const messageHandler = (msg, cb) => {
   const payload = msg.getBody();
   console.log('Message payload', payload);
   cb(); // acknowledging the message
};

consumer.consume('test_queue', messageHandler, (err) => {
   if (err) console.error(err);
});

consumer.run();
Message Acknowledgement

Once a message is received, to acknowledge it, you invoke the callback function without arguments, as shown in the example above.

Message acknowledgment informs the MQ that the delivered message has been successfully consumed.

If an error occurred while processing a message, you can unacknowledge it by passing in the error to the callback function.

By default, unacknowledged messages are re-queued and delivered again unless message retry threshold is exceeded.

Delivered messages that couldn't be processed or can not be delivered to consumers are moved to a system generated queue called dead-letter queue (DLQ).

By default, RedisSMQ does not store acknowledged and dead-lettered messages for saving disk and memory spaces, and also to increase message processing performance.

If you need such feature, you can enable it from your configuration object.

See Consumer Reference for more details.

Advanced Topics

RedisSMQ Architecture

Performance

See Performance for more details.

Contributing

So you are interested in contributing to this project? Please see CONTRIBUTING.md.

License

MIT

Keywords

FAQs

Package last updated on 26 Mar 2023

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc