Dead letter queue pattern in Kafka - Step-by-Step Execution

Process Flow - Dead letter queue pattern

Message Produced

↓

Message Consumed

↓

Process Message

↓

Success

↓

Commit

↓

Dead Letter Queue

Messages are produced and consumed. If processing succeeds, message is committed. If it fails, message is sent to a Dead Letter Queue (DLQ) for later inspection.

Execution Sample

Kafka

message = consumer.poll()
try:
  process(message)
  consumer.commit()
except Exception:
  producer.send('DLQ', message)
  consumer.commit()

Consume a message, try to process it, commit if success, else send to DLQ.

Process Table

Step	Action	Message Content	Processing Result	Queue Destination	Output
1	Poll message	Order #123	N/A	Main Topic	Message received
2	Process message	Order #123	Success	Main Topic	Processed successfully
3	Commit offset	Order #123	N/A	Main Topic	Offset committed
4	Poll message	Order #124	N/A	Main Topic	Message received
5	Process message	Order #124	Failure	Main Topic	Processing failed
6	Send to DLQ	Order #124	N/A	Dead Letter Queue	Message sent to DLQ
7	Poll message	Order #125	N/A	Main Topic	Message received
8	Process message	Order #125	Success	Main Topic	Processed successfully
9	Commit offset	Order #125	N/A	Main Topic	Offset committed

💡 No more messages to consume

Status Tracker

Variable	Start	After Step 3	After Step 6	After Step 9	Final
message	None	Order #123	Order #124	Order #125	Order #125
processing_result	None	Success	Failure	Success	Success
queue_destination	Main Topic	Main Topic	Dead Letter Queue	Main Topic	Main Topic

Key Moments - 3 Insights

Why do we send the message to the Dead Letter Queue instead of just discarding it?

Because the message failed processing and we want to keep it for later inspection or reprocessing, as shown in execution_table step 6.

What happens if the message processing succeeds?

The message offset is committed to mark it as processed, so it won't be consumed again, as shown in execution_table steps 3 and 9.

Does sending to the DLQ stop the consumer from processing other messages?

No, the consumer continues polling and processing other messages normally, as seen in steps 7-9.

Visual Quiz - 3 Questions

Look at the execution_table, what is the queue destination for the message 'Order #124' after processing fails?

A Main Topic

B Dead Letter Queue

C Committed Offsets

D Discarded

💡 Hint

Check step 6 in the execution_table where the message is sent after failure.

At which step does the consumer commit the offset for a successfully processed message?

A Step 2

B Step 5

C Step 3

D Step 6

💡 Hint

Look for 'Commit offset' action in the execution_table.

If the processing of 'Order #125' failed, how would the queue destination change in the execution_table?

A It would change to 'Dead Letter Queue'

B It would be 'Committed Offsets'

C It would remain 'Main Topic'

D It would be 'Discarded'

💡 Hint

Refer to how failure is handled for 'Order #124' in steps 5 and 6.

Concept Snapshot

Dead Letter Queue Pattern:
- Consume messages from main topic
- Try processing each message
- On success: commit offset
- On failure: send message to DLQ
- DLQ stores failed messages for later handling

Full Transcript

This visual trace shows how the Dead Letter Queue pattern works in Kafka. Messages are consumed from the main topic. Each message is processed. If processing succeeds, the consumer commits the offset so the message won't be reprocessed. If processing fails, the message is sent to a special topic called the Dead Letter Queue (DLQ). This DLQ holds failed messages for later inspection or retry. The consumer continues processing other messages normally. This pattern helps handle errors without losing messages or blocking the consumer.

Practice

1. What is the main purpose of a Dead Letter Queue (DLQ) in Kafka?

easy

A. To store messages that failed processing for later analysis

B. To speed up message processing by duplicating messages

C. To permanently delete messages after processing

D. To encrypt messages before sending to consumers

Solution

1. Step 1: Understand the role of DLQ

   A Dead Letter Queue is used to hold messages that cannot be processed successfully by the main consumer.

2. Step 2: Identify the purpose of storing failed messages

   Storing failed messages allows developers to analyze and fix issues without blocking the main processing flow.

3. Final Answer:

   To store messages that failed processing for later analysis -> Option A

4. Quick Check:

   DLQ = store failed messages [OK]

Hint: DLQ holds failed messages to avoid blocking main flow [OK]

Common Mistakes:

• Thinking DLQ speeds up processing by duplicating messages
• Confusing DLQ with message deletion
• Assuming DLQ encrypts messages

2. Which Kafka configuration is commonly used to specify the Dead Letter Queue topic for a consumer?

easy

A. enable.auto.commit

B. auto.offset.reset

C. max.poll.records

D. dead.letter.queue.topic.name

Solution

1. Step 1: Identify DLQ related configuration

   The configuration dead.letter.queue.topic.name is used to specify the topic where failed messages are sent.

2. Step 2: Differentiate from other common configs

   Other options like enable.auto.commit and auto.offset.reset control offset behavior, not DLQ.

3. Final Answer:

   dead.letter.queue.topic.name -> Option D

4. Quick Check:

   DLQ topic config = dead.letter.queue.topic.name [OK]

Hint: DLQ topic config usually contains 'dead.letter.queue' phrase [OK]

Common Mistakes:

• Confusing offset configs with DLQ topic config
• Using unrelated consumer configs for DLQ
• Assuming DLQ is automatic without config

3. Given the following Kafka consumer code snippet, what happens when message processing fails?

try {
  processMessage(record);
} catch (Exception e) {
  producer.send(new ProducerRecord<>("dlq-topic", record.key(), record.value()));
}

medium

A. The message is silently dropped without notification

B. The message is retried immediately in the same consumer loop

C. The failed message is sent to the "dlq-topic" for later review

D. The consumer stops processing all messages

Solution

1. Step 1: Analyze the catch block behavior

   When an exception occurs, the code sends the failed message to the "dlq-topic" using a producer.

2. Step 2: Understand the effect on message processing

   The message is not retried or dropped silently; it is stored in the DLQ topic for later analysis.

3. Final Answer:

   The failed message is sent to the "dlq-topic" for later review -> Option C

4. Quick Check:

   Exception handling sends message to DLQ [OK]

Hint: Catch block sends failed messages to DLQ topic [OK]

Common Mistakes:

• Assuming immediate retry happens automatically
• Thinking consumer stops on failure
• Believing message is dropped silently

4. Identify the error in this Kafka consumer code snippet that tries to send failed messages to a DLQ:

try {
  process(record);
} catch (Exception e) {
  producer.send("dlq-topic", record.key(), record.value());
}

medium

A. The catch block should rethrow the exception

B. The producer.send method is missing a ProducerRecord object

C. The process method should not be inside try-catch

D. The record.key() cannot be used as a message key

Solution

1. Step 1: Check the producer.send method usage

   The producer.send method requires a ProducerRecord object, not separate parameters.

2. Step 2: Identify correct usage

   The correct call is producer.send(new ProducerRecord<>("dlq-topic", record.key(), record.value()));

3. Final Answer:

   The producer.send method is missing a ProducerRecord object -> Option B

4. Quick Check:

   producer.send needs ProducerRecord object [OK]

Hint: producer.send requires ProducerRecord, not separate args [OK]

Common Mistakes:

• Passing topic and data as separate arguments to send
• Ignoring exception handling best practices
• Misusing record key as invalid

5. You want to implement a Dead Letter Queue pattern in Kafka that retries failed messages up to 3 times before sending them to the DLQ. Which approach correctly achieves this?

hard

A. Use a retry counter in message headers; on failure increment and retry, else send to DLQ after 3 tries

B. Send all failed messages immediately to DLQ without retries

C. Configure Kafka broker to automatically retry messages 3 times before DLQ

D. Use a separate consumer that deletes messages after 3 retries

Solution

1. Step 1: Understand retry logic with DLQ

   Retries require tracking how many times a message was processed; using headers to count retries is common.

2. Step 2: Implement conditional retry or DLQ send

   If retry count is less than 3, retry processing; if 3 or more, send message to DLQ topic.

3. Step 3: Evaluate other options

   Kafka broker does not handle retries automatically; immediate DLQ send skips retries; deleting messages after retries is incorrect.

4. Final Answer:

   Use a retry counter in message headers; on failure increment and retry, else send to DLQ after 3 tries -> Option A

5. Quick Check:

   Retry count in headers controls DLQ after 3 tries [OK]

Hint: Track retries in headers; send to DLQ after max retries [OK]

Common Mistakes:

• Expecting Kafka broker to retry automatically
• Sending all failures immediately to DLQ
• Deleting messages instead of sending to DLQ