Redis SMQ持久化疑问：消费者中断重启后能否续接未消费消息？

Great question—this is exactly the reliability scenario message queues are built for, and Redis SMQ handles it effectively, but the behavior hinges on a few critical configurations you need to get right.

Here's the breakdown:

• First, ensure messages are persisted
  For this to work at all, your producers must publish messages with persistence enabled. Redis SMQ stores persistent messages in Redis's durable storage (backed by RDB/AOF persistence, which you should also have enabled on your Redis instance). This guarantees messages aren't lost if Redis itself restarts, let alone just a consumer.

• Use manual message acknowledgments (ACKs)
  This is the make-or-break setting. By default, some Redis SMQ consumer setups use auto-ACK, meaning the queue marks a message as processed as soon as it's sent to the consumer. If the consumer crashes right after receiving the message but before processing it, that message is gone forever.

  Instead, enable manual ACK mode: the consumer only sends an acknowledgment once it's successfully finished processing the message. If the consumer crashes mid-processing, the message remains in the queue's "in-flight" state. Once the consumer reconnects, Redis SMQ will re-deliver those unacknowledged messages.

  Example configuration (Node.js client):

  const { Consumer } = require('redis-smq');
  const consumer = new Consumer();
  
  consumer.consume('my-target-queue', async (msg, cb) => {
    try {
      // Your message processing logic here
      await handleMessage(msg.content);
      // Confirm successful processing
      cb();
    } catch (error) {
      // Handle failure (retry, send to dead-letter queue, etc.)
      cb(error);
    }
  }, {
    autoAck: false, // Disable auto-ACK to use manual confirmation
    visibilityTimeout: 30000, // 30-second window: if no ACK, requeue the message
  });
  

• Reconnection picks up where you left off
  When your consumer restarts and reconnects to Redis SMQ, it will automatically resubscribe to the queues it was watching. The queue will deliver:

  1. All unacknowledged messages that were in-flight when the consumer crashed
  2. Any new messages published to the queue while the consumer was offline

  The visibilityTimeout setting I mentioned earlier acts as a safety net: if a consumer takes too long to process a message (or crashes), the queue will automatically move the message back to the "pending" state after the timeout, ensuring it gets picked up by either the restarted consumer or another available consumer.

Key Takeaway #

As long as you have persistent messages, manual ACKs enabled, and a reasonable visibilityTimeout configured, your consumer will absolutely resume consumption from the point it disconnected—no lost messages, no gaps in processing. Skip any of these steps, and you risk losing messages during consumer outages.

内容的提问来源于stack exchange，提问作者Sindhu Raju