Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Use XGROUP CREATE to establish a group, XREADGROUP to distribute new entries to named consumers, and XACK after successful processing. Redis keeps delivered but unacknowledged entries pending; inspect them with XPENDING and recover abandoned work with XCLAIM or XAUTOCLAIM. Because recovery can redeliver a message, make processing safe to retry.
What a Redis Streams consumer group does
A consumer group lets multiple named consumers share entries from one Redis stream. Within a group, consumers receive available work rather than each receiving an independent copy of every new entry. A separate group has its own consumption state and can read the same stream independently—for example, two applications can use different groups to perform separate jobs on the same events.
Reading an entry with XREADGROUP does not delete it or mark its work complete. Redis records the delivery in that group’s Pending Entries List (PEL) until the entry is acknowledged. This pending state is what allows inspection and recovery when a consumer stops before finishing.
Create a group with the right starting position
Use XGROUP CREATE with the stream key, group name, and an ID:
#1 Best Overall
XGROUP CREATE stream-key group-name start-idThe starting ID determines which existing entries are eligible as initial work:
- Use
0-0when the group should begin with the stream’s historical entries. - Use
$when the group should start at the current end and receive entries added afterward, rather than treating the existing backlog as new work.
Add MKSTREAM when you want Redis to create the stream key if it does not already exist. For example:
XGROUP CREATE orders order-workers 0-0 MKSTREAMDecide whether the group should process backlog or only future entries before creating it. That startup choice determines whether older stream entries become the group’s initial work.
Rank #2
Read new entries with named consumers
Each worker uses the same stream and group names but supplies its own consumer name. The special ID > requests entries that have not previously been delivered to a consumer in that group:
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchXREADGROUP GROUP group-name consumer-name COUNT 10 BLOCK 5000 STREAMS stream-key >COUNTlimits the number of entries requested in a batch.BLOCKmakes the call wait for work for the specified time in milliseconds.- Choose consumer names that let you identify workers when examining pending entries.
Multiple consumers in one group can share the stream’s available work. If another independent application needs its own full read of the stream, give it a separate group rather than adding it as a consumer of the first application’s group.
Process entries before acknowledging them
For each entry returned, complete the application work first and then acknowledge that entry for the group:
XACK stream-key group-name entry-idAn acknowledgment removes the entry’s pending reference for that group; it does not delete the stream entry. Acknowledging before the work succeeds can leave unfinished work outside normal pending-entry recovery. Acknowledging after success means a failure before the acknowledgment may result in the work being delivered again. Design handlers and side effects to tolerate retries, or use application-level deduplication where needed.
Inspect and recover pending entries
Use XPENDING to inspect outstanding entries, including their consumers and idle time. Pending entries are not automatically proof that a consumer has failed: a slow but healthy worker may still be processing one. Recovery should account for normal processing duration.
Claim selected entries with XCLAIM
Use XCLAIM when you have identified particular pending entry IDs to transfer. Supply a minimum idle duration so the entry is eligible for reassignment only after it has been idle long enough:
XCLAIM stream-key group-name new-consumer-name min-idle-time entry-idScan for idle entries with XAUTOCLAIM
Use XAUTOCLAIM to scan pending entries and claim those that meet the minimum idle duration. Continue scanning from the cursor returned by Redis as described in the XAUTOCLAIM command documentation.
Set the idle threshold above the time a normally slow operation may take. A threshold that is too short can cause a healthy consumer’s entry to be claimed while it is still being processed. A claimed entry can be processed again, so recovery does not remove the need for retry-safe handling.
Choose retention, batch size, and recovery settings for the workload
There is no universal production value for stream retention, batch size, or minimum idle time. Make the choices against your application’s replay and recovery needs:
Recommended Free Tools
Best Value
- Retention: trimming reduces the history available for replay. Base it on the application’s retention contract and verify trimming behavior for the Redis version you deploy.
- Batch size: use
COUNTto bound the amount requested at once, considering how much work a consumer can process reliably. - Idle threshold: allow for normal processing time while keeping recovery responsive when a consumer has actually stopped.
- Recovery method: use
XCLAIMfor selected entries orXAUTOCLAIMto scan and claim idle pending work.
These settings involve trade-offs between replay history, throughput, and recovery time; benchmark values are not established by the Redis documentation cited here and should not be assumed for a different workload.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Understand delivery guarantees and scaling boundaries
Redis’s Streams guide describes consumer-group processing as at-least-once: an unacknowledged entry can remain pending and be reassigned. That is useful for recovery but permits duplicate processing. Consumer-group acknowledgments do not make application side effects exactly-once, nor do they alone guarantee survival through every infrastructure failure. Durability also depends on the deployment’s persistence and replication configuration.
Redis 8.6 supports idempotent message production with XADD in supported scenarios, as described in the Redis idempotency documentation. This addresses certain duplicate-production risks, such as uncertainty after a connection issue; it does not make consumer-side effects exactly-once. Confirm that the deployed server and client support the feature before relying on it.
A consumer group load-balances work from a stream key; it does not automatically partition that key across Redis instances. If the design needs work divided across keys or instances, use multiple stream keys with an application-level or cluster-sharding design.
Quick Recap
A practical decision checklist
- Should a new group process existing entries (
0-0) or only entries added after setup ($)? - Does each independent application need its own group?
- Does each worker have a stable, identifiable consumer name?
- Does the application acknowledge only after its work succeeds?
- Can processing safely run again after a failure or claim?
- Is the idle threshold longer than legitimate processing time?
- Does stream trimming preserve the history required for replay and recovery?
- Does the scaling design account for a stream being one key rather than an automatic partition across instances?
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
