Replay dead letters
- Choose the messages
- Choose the target
- Go easy on the consumers
- One message first: the canary
- What a replay promises
- Did it help?
A replay puts messages from a dead-letter queue back into circulation. By default each one goes to the exchange and routing key it was originally published to, read from its x-death header, so it reaches the same consumers as before.

Choose the messages
On the queue page, group the dead letters by Exception, Reason, Died in, Routing key or Deaths and click a group to narrow the table. Then:
- Selected in the table: tick the rows (
xon the keyboard,Shift+Afor all) and press Replay orr. - First N: the oldest N from the head of the queue.
- Matching: every message that fits the search or the reason group, in the whole queue, not only the loaded rows.
"First N" and "Matching" are checked with a dry run first, so the replay takes exactly the messages you saw.

Choose the target
- Original route from
x-death, or from thex-original-*headers of Spring'sRepublishMessageRecoverer, or the endpoint exchange of a MassTransit_errorqueue. Of thex-deathentries Warren takes the most recent one where a consumer or a limit gave up, so a message from a broker-side retry loop goes back to the consumer and not into the wait queue it last expired from. - Queue: straight into a named queue through the default exchange. Type part of the name right in the field; the list narrows as you type.
- Exchange with a routing key of your choice.
Select one message to edit its payload or headers before it goes out; the audit log keeps the original next to the edited version.
Go easy on the consumers
Limit the speed to N messages per second spaces the publishes evenly, so a consumer that just recovered is not flooded again. A throttled replay may take at most 25 minutes, because RabbitMQ takes back deliveries that stay unacknowledged longer than its consumer_timeout (30 minutes by default; RabbitMQ 4.3 applies it to quorum queues only).
Every replay runs in the background: the dialog closes as soon as the replay has started, and the replay's page shows the progress, replayed and failed so far, and can stop it. (A script calling the API gets the final result in the response instead, unless it asks for ?background=true or sets a rate.)
One message first: the canary
Canary replays the first message of the selection alone and watches the source queue for it during the wait (2 minutes by default, 5 seconds to 30 minutes). If the message is back in the queue with a fresh death by then, the replay stops and the rest stays where it was; if not, the rest follows, at the rate you set. The replay runs in the background; its page says "Canary out" with the time the wait ends, then "Canary passed" or "Canary died again", and the audit log shows a stopped replay with the reason.
Use it when the fix is not certain: one order goes through the repaired consumer first, 142 do not pile up again behind it. The canary looks only in the source queue, so a message that dies into another dead-letter queue is not caught by it (the replay's outcome below still counts it later). Mnemonic c in the dialog; the Failures page's replay has the same option per queue. In the API: "canary": {"waitSeconds": 120} on the replay request.
What a replay promises
- Warren reads each message without acknowledging it.
- It publishes the message with
mandatoryand publisher confirms. Only after the broker confirms does it acknowledge the original. - Everything it did not take goes back with
nackandrequeue; a crash releases it the same way.
No message is lost. If Warren dies between the broker's confirm and its own acknowledgement, the messages of that moment are delivered twice, so consumers should be idempotent, as RabbitMQ itself recommends.
Death headers (x-death, x-first-death-*, x-last-death-*), MassTransit's MT-Fault-* and a quorum queue's x-delivery-count are removed, so the message starts with a fresh retry budget. Warren adds x-warren-replay-id, x-warren-source-queue and x-warren-replayed-at, so you can tell a replayed message from a new one.
Every replay is in the Audit log with who, when, which route, and the outcome per message.
Did it help?
A replay that publishes cleanly can still fail again a minute later. Warren notices: a replayed message carries x-warren-replay-id, and when one turns up again in a dead-letter queue with a new x-death (or, for consumers that republish failures themselves, in a queue named like a dead-letter queue), it is counted against its replay.

The replay's page then says "5 of 143 replayed messages died again: 5 back in orders.dlq. The other 138 are not back in a dead-letter queue (96 %)", and marks those five back in DLQ in its message list. The audit log shows "5 back" next to the count.
Every read of a queue looks for returns: opening a queue page, the Failures page, a replay rule's run. On top of that Warren reads the source queue itself 5 minutes, 30 minutes, 2 hours and a day after each replay, and says how much of it each check read. A check takes the head of the queue, the first 200 messages: in a queue that holds thousands of older dead letters, returns further back are found once the queue is worked off.
"Not back" means not seen in a dead-letter queue: the consumer took the message, or it sits further back than Warren read. An edited message comes back with a different body and is not matched to its replay.