Dead Letter Queue Pattern

Overview

The Dead Letter Queue (DLQ) pattern is an essential error handling mechanism in message-driven architectures that provides a systematic approach to managing messages that cannot be processed successfully. It serves as a safety net for failed message processing, ensuring that problematic messages are preserved for analysis and potential reprocessing rather than being lost or causing system instability.

Theoretical Foundation

The Dead Letter Queue pattern is rooted in message queuing theory and fault tolerance engineering. It addresses the fundamental challenge that in asynchronous message processing systems, not all messages can be processed successfully due to various failure conditions. The pattern embodies the principle of "graceful failure handling" - ensuring that processing failures don't result in data loss or system degradation.

Core Principles

1. Message Preservation

The DLQ ensures that no messages are permanently lost due to processing failures, maintaining data integrity and enabling failure analysis.

2. System Protection

By removing problematic messages from main processing queues, DLQs prevent poison messages from blocking healthy message processing.

3. Failure Analysis

DLQs provide a centralized location for analyzing failed messages, enabling teams to identify and resolve systematic processing issues.

4. Operational Control

The pattern enables manual intervention and reprocessing of failed messages once underlying issues are resolved.

Why Dead Letter Queues are Essential in Integration Architecture

1. Message Processing Reliability

In event-driven architectures, messages may fail to process due to: - Temporary resource unavailability causing processing to fail - Data validation errors in message payloads - Business logic exceptions during message handling - External service dependencies being unavailable during processing

2. Poison Message Management

Certain messages can consistently cause processing failures: - Malformed message formats that cannot be deserialized - Invalid data values that cause application exceptions - Messages requiring unavailable resources or external dependencies - Messages with corrupted or incomplete data

3. System Stability Protection

Without DLQs, failed messages can: - Block queue processing when retry limits are exceeded - Consume processing resources through infinite retry loops - Cause memory issues from accumulating failed message processing attempts - Impact system performance by repeatedly processing known bad messages

4. Operational Visibility

DLQs provide essential operational capabilities: - Failure rate monitoring through DLQ message volume tracking - Error pattern analysis by examining failed message characteristics - Manual intervention points for resolving systematic issues - Recovery mechanisms for reprocessing messages after fixes

Benefits in Integration Contexts

1. Data Integrity Assurance

• No message loss even during processing failures
• Complete audit trail of all processing attempts
• Preserves original message content for analysis and reprocessing
• Maintains message ordering where applicable

2. System Resilience

• Prevents poison message impacts on healthy message processing
• Maintains queue throughput by isolating problematic messages
• Enables graceful degradation during systematic processing issues
• Protects against cascading failures from bad messages

3. Operational Excellence

• Centralized error handling for message processing failures
• Systematic failure analysis through DLQ message examination
• Monitoring and alerting based on DLQ volume and patterns
• Manual intervention capabilities for edge case handling

4. Recovery and Reprocessing

• Batch reprocessing of failed messages after issue resolution
• Selective message recovery for specific failure types
• Testing and validation using real failed messages
• Gradual rollout of fixes through controlled reprocessing

Integration Architecture Applications

1. Event-Driven Microservices

DLQs in microservice architectures handle: - Inter-service communication failures when downstream services are unavailable - Event schema evolution where old messages can't be processed by new versions - Business rule violations that prevent event processing completion

2. API Gateway Integration

API gateways use DLQs for: - Webhook delivery failures to external systems - Rate limiting violations causing message delivery delays - Authentication failures in outbound API calls

3. Data Pipeline Processing

In data processing pipelines, DLQs manage: - Data transformation failures due to unexpected input formats - Data quality issues that prevent successful processing - Downstream system failures affecting data delivery

4. Legacy System Integration

When integrating with legacy systems: - Protocol mismatches causing communication failures - Data format incompatibilities preventing successful processing - Legacy system unavailability during maintenance windows

How Dead Letter Queue Works

The DLQ pattern operates through automatic redirection of failed messages after retry attempts are exhausted:

Message Processing Flow

Incoming Message
    ↓
Process Message
    ↓
Success? ───Yes───→ Acknowledge Message
    ↓ No
Retryable Error?───No───→ Send to DLQ
    ↓ Yes
Retry Attempts < Max?───No───→ Send to DLQ
    ↓ Yes
Retry Processing
    ↓
Wait Retry Delay
    ↓
← Process Message

DLQ Architecture Components

Main Queue → Message Processor → Success
    ↓              ↓
    ↓           Failure
    ↓              ↓
    ↓          Retry Logic
    ↓              ↓
    ↓        Max Retries?
    ↓              ↓
    └─────→ Dead Letter Queue
                   ↓
            DLQ Message Handler
                   ↓
            Analysis & Recovery

Message Lifecycle in DLQ

1. Original Processing Failure
2. Retry Attempts (with backoff)
3. DLQ Placement (with metadata)
4. DLQ Monitoring & Analysis
5. Manual Intervention & Fix
6. Message Reprocessing
7. Success or Permanent Failure

Key Components

1. DLQ Configuration

Manages DLQ behavior and policies:

public class DeadLetterQueueConfig {
    private final String dlqName;
    private final int maxRetries;
    private final Duration retryDelay;
    private final Duration dlqRetentionPeriod;
    private final Set<Class<? extends Throwable>> dlqExceptions;

    public static class Builder {
        private String dlqName;
        private int maxRetries = 3;
        private Duration retryDelay = Duration.ofSeconds(30);
        private Duration dlqRetentionPeriod = Duration.ofDays(7);
        private Set<Class<? extends Throwable>> dlqExceptions = new HashSet<>();

        public Builder dlqName(String name) {
            this.dlqName = name;
            return this;
        }

        public Builder maxRetries(int retries) {
            this.maxRetries = retries;
            return this;
        }

        public Builder addDlqException(Class<? extends Throwable> exceptionClass) {
            this.dlqExceptions.add(exceptionClass);
            return this;
        }

        public DeadLetterQueueConfig build() {
            Objects.requireNonNull(dlqName, "DLQ name is required");
            return new DeadLetterQueueConfig(
                dlqName, maxRetries, retryDelay, 
                dlqRetentionPeriod, dlqExceptions
            );
        }
    }
}

2. DLQ Message Wrapper

Preserves original message with failure metadata:

public class DlqMessage<T> {
    private final T originalMessage;
    private final String originalQueue;
    private final Instant firstFailureTime;
    private final Instant lastFailureTime;
    private final int failureCount;
    private final List<FailureRecord> failureHistory;
    private final Map<String, String> headers;

    public static class FailureRecord {
        private final Instant timestamp;
        private final String exceptionType;
        private final String errorMessage;
        private final String stackTrace;
        private final int attemptNumber;

        public FailureRecord(Throwable exception, int attemptNumber) {
            this.timestamp = Instant.now();
            this.exceptionType = exception.getClass().getSimpleName();
            this.errorMessage = exception.getMessage();
            this.stackTrace = getStackTraceAsString(exception);
            this.attemptNumber = attemptNumber;
        }
    }

    public DlqMessage<T> addFailure(Throwable exception, int attemptNumber) {
        List<FailureRecord> updatedHistory = new ArrayList<>(failureHistory);
        updatedHistory.add(new FailureRecord(exception, attemptNumber));

        return new DlqMessage<>(
            originalMessage,
            originalQueue,
            firstFailureTime != null ? firstFailureTime : Instant.now(),
            Instant.now(),
            failureCount + 1,
            updatedHistory,
            headers
        );
    }
}

3. DLQ Message Handler

Processes messages sent to dead letter queue:

@Component
public class DeadLetterQueueHandler {
    private final DlqMessageRepository dlqRepository;
    private final NotificationService notificationService;
    private final MetricsService metricsService;

    public void handleDlqMessage(DlqMessage<?> dlqMessage) {
        try {
            // Store message in DLQ storage
            dlqRepository.save(dlqMessage);

            // Record metrics
            metricsService.incrementDlqCounter(
                dlqMessage.getOriginalQueue(),
                dlqMessage.getLastFailureType()
            );

            // Check if alert thresholds are exceeded
            if (shouldTriggerAlert(dlqMessage)) {
                notificationService.sendDlqAlert(dlqMessage);
            }

            log.info("Message sent to DLQ: queue={}, failureCount={}, lastError={}",
                dlqMessage.getOriginalQueue(),
                dlqMessage.getFailureCount(),
                dlqMessage.getLastFailureType()
            );

        } catch (Exception e) {
            // Critical: DLQ processing failed
            log.error("Failed to process DLQ message: {}", dlqMessage, e);

            // Send critical alert
            notificationService.sendCriticalAlert(
                "DLQ processing failure", e, dlqMessage
            );
        }
    }

    private boolean shouldTriggerAlert(DlqMessage<?> dlqMessage) {
        // Alert on first failure of each type
        if (dlqMessage.getFailureCount() == 1) {
            return true;
        }

        // Alert if DLQ volume exceeds threshold
        long recentDlqCount = dlqRepository.countRecentMessages(
            dlqMessage.getOriginalQueue(),
            Duration.ofHours(1)
        );

        return recentDlqCount > DLQ_ALERT_THRESHOLD;
    }
}

4. DLQ Recovery Service

Manages reprocessing of DLQ messages:

@Service
public class DlqRecoveryService {
    private final MessageProcessor messageProcessor;
    private final DlqMessageRepository dlqRepository;

    public RecoveryResult reprocessMessages(DlqRecoveryRequest request) {
        List<DlqMessage<?>> messages = dlqRepository.findMessagesForRecovery(request);

        RecoveryResult result = new RecoveryResult();

        for (DlqMessage<?> dlqMessage : messages) {
            try {
                // Attempt to reprocess original message
                messageProcessor.process(dlqMessage.getOriginalMessage());

                // Mark as successfully recovered
                dlqRepository.markAsRecovered(dlqMessage.getId());
                result.addSuccess(dlqMessage.getId());

            } catch (Exception e) {
                // Reprocessing failed
                log.warn("DLQ message reprocessing failed: {}", dlqMessage.getId(), e);
                result.addFailure(dlqMessage.getId(), e.getMessage());

                // Update failure count if within limits
                if (dlqMessage.getFailureCount() < MAX_DLQ_RETRIES) {
                    DlqMessage<?> updatedMessage = dlqMessage.addFailure(e, dlqMessage.getFailureCount() + 1);
                    dlqRepository.update(updatedMessage);
                } else {
                    // Permanent failure - mark as unrecoverable
                    dlqRepository.markAsUnrecoverable(dlqMessage.getId());
                }
            }
        }

        return result;
    }
}

Configuration Parameters

Essential Settings

Example Configuration

# Dead Letter Queue configuration
dlq.default.max-retries=5
dlq.default.retry-delay=30s
dlq.default.retention-period=14d
dlq.default.alert-threshold=50

# Queue-specific DLQ settings
dlq.contact-updates.max-retries=3
dlq.contact-updates.retry-delay=60s
dlq.contact-updates.retention-period=7d

dlq.critical-notifications.max-retries=10
dlq.critical-notifications.retry-delay=10s
dlq.critical-notifications.retention-period=30d

Implementation Examples

1. RabbitMQ Dead Letter Queue

@Configuration
public class RabbitDlqConfiguration {

    @Bean
    public Queue mainQueue() {
        return QueueBuilder.durable("contact.updates")
            .deadLetterExchange("dlq.exchange")
            .deadLetterRoutingKey("contact.updates.dlq")
            .ttl(300000) // 5 minutes before DLQ
            .build();
    }

    @Bean
    public Queue deadLetterQueue() {
        return QueueBuilder.durable("contact.updates.dlq")
            .build();
    }

    @Bean
    public DirectExchange dlqExchange() {
        return new DirectExchange("dlq.exchange");
    }

    @Bean
    public Binding dlqBinding() {
        return BindingBuilder
            .bind(deadLetterQueue())
            .to(dlqExchange())
            .with("contact.updates.dlq");
    }
}

@RabbitListener(queues = "contact.updates")
public class ContactUpdateListener {

    public void handleContactUpdate(@Payload ContactUpdateEvent event,
                                  @Header Map<String, Object> headers,
                                  Channel channel,
                                  @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) {
        try {
            contactService.processUpdate(event);
            channel.basicAck(deliveryTag, false);

        } catch (RetryableException e) {
            // Let RabbitMQ handle retry and eventual DLQ
            log.warn("Retryable error processing contact update: {}", e.getMessage());
            channel.basicNack(deliveryTag, false, true);

        } catch (NonRetryableException e) {
            // Send directly to DLQ
            log.error("Non-retryable error, sending to DLQ: {}", e.getMessage());
            channel.basicNack(deliveryTag, false, false);
        }
    }
}

2. Kafka Dead Letter Topic

@Service
public class KafkaDlqHandler {
    private final KafkaTemplate<String, Object> kafkaTemplate;

    @KafkaListener(topics = "contact-updates")
    public void handleContactUpdate(ConsumerRecord<String, ContactUpdateEvent> record) {
        try {
            contactService.processUpdate(record.value());

        } catch (Exception e) {
            handleProcessingFailure(record, e);
        }
    }

    private void handleProcessingFailure(ConsumerRecord<String, ContactUpdateEvent> record, 
                                       Exception exception) {

        // Create DLQ message with failure metadata
        DlqMessage<ContactUpdateEvent> dlqMessage = DlqMessage.<ContactUpdateEvent>builder()
            .originalMessage(record.value())
            .originalTopic(record.topic())
            .originalPartition(record.partition())
            .originalOffset(record.offset())
            .failureException(exception)
            .failureTimestamp(Instant.now())
            .retryCount(getRetryCount(record))
            .build();

        // Send to DLQ topic
        String dlqTopic = record.topic() + ".dlq";
        kafkaTemplate.send(dlqTopic, record.key(), dlqMessage)
            .addCallback(
                result -> log.info("Message sent to DLQ: {}", dlqTopic),
                failure -> log.error("Failed to send message to DLQ", failure)
            );
    }

    private int getRetryCount(ConsumerRecord<String, ContactUpdateEvent> record) {
        Header retryHeader = record.headers().lastHeader("retry-count");
        return retryHeader != null ? 
            ByteBuffer.wrap(retryHeader.value()).getInt() : 0;
    }
}

3. Amazon SQS Dead Letter Queue

@Configuration
public class SqsDlqConfiguration {

    @Bean
    public Queue mainQueue(AmazonSQS amazonSQS) {
        String dlqUrl = createDeadLetterQueue(amazonSQS);

        Map<String, String> attributes = Map.of(
            "VisibilityTimeoutSeconds", "300",
            "MessageRetentionPeriod", "1209600", // 14 days
            "RedrivePolicy", String.format(
                "{\"deadLetterTargetArn\":\"arn:aws:sqs:%s:%s:%s\",\"maxReceiveCount\":3}",
                region, accountId, "contact-updates-dlq"
            )
        );

        CreateQueueRequest request = new CreateQueueRequest()
            .withQueueName("contact-updates")
            .withAttributes(attributes);

        return new Queue(amazonSQS.createQueue(request).getQueueUrl());
    }

    private String createDeadLetterQueue(AmazonSQS amazonSQS) {
        CreateQueueRequest dlqRequest = new CreateQueueRequest()
            .withQueueName("contact-updates-dlq")
            .withAttributes(Map.of(
                "MessageRetentionPeriod", "1209600" // 14 days
            ));

        return amazonSQS.createQueue(dlqRequest).getQueueUrl();
    }
}

@SqsListener("contact-updates")
public class SqsContactUpdateHandler {

    public void handleMessage(@Payload ContactUpdateEvent event,
                            @Header Map<String, String> headers) {
        try {
            contactService.processUpdate(event);

        } catch (Exception e) {
            log.error("Failed to process contact update, will be retried by SQS: {}", 
                     e.getMessage());
            throw e; // Let SQS handle retry and DLQ
        }
    }
}

4. Custom DLQ Implementation

@Component
public class CustomDlqProcessor {
    private final RedisTemplate<String, Object> redisTemplate;
    private final NotificationService notificationService;

    public <T> void processWithDlq(T message, 
                                  String queueName,
                                  Consumer<T> processor,
                                  DeadLetterQueueConfig config) {

        String messageId = generateMessageId();
        DlqMessage<T> dlqMessage = new DlqMessage<>(message, queueName);

        int attempts = 0;
        while (attempts < config.getMaxRetries()) {
            try {
                attempts++;
                processor.accept(message);
                return; // Success

            } catch (Exception e) {
                dlqMessage = dlqMessage.addFailure(e, attempts);

                if (isNonRetryable(e, config)) {
                    log.warn("Non-retryable exception, sending to DLQ immediately: {}", 
                            e.getMessage());
                    break;
                }

                if (attempts < config.getMaxRetries()) {
                    Duration delay = calculateRetryDelay(attempts, config);
                    log.warn("Processing failed (attempt {}/{}), retrying in {}: {}", 
                            attempts, config.getMaxRetries(), delay, e.getMessage());

                    try {
                        Thread.sleep(delay.toMillis());
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }

        // All retries exhausted, send to DLQ
        sendToDlq(dlqMessage, config);
    }

    private void sendToDlq(DlqMessage<?> dlqMessage, DeadLetterQueueConfig config) {
        String dlqKey = "dlq:" + config.getDlqName() + ":" + UUID.randomUUID();

        redisTemplate.opsForValue().set(
            dlqKey, 
            dlqMessage, 
            config.getDlqRetentionPeriod()
        );

        // Record metrics and send alerts
        recordDlqMetrics(dlqMessage);

        if (shouldAlert(dlqMessage)) {
            notificationService.sendDlqAlert(dlqMessage);
        }

        log.error("Message sent to DLQ: queue={}, messageId={}, failures={}", 
                 dlqMessage.getOriginalQueue(),
                 dlqKey,
                 dlqMessage.getFailureCount());
    }
}

Best Practices

1. DLQ Message Analysis

@Service
public class DlqAnalysisService {

    public DlqAnalysisReport analyzeDlqMessages(String queueName, Duration period) {
        List<DlqMessage<?>> messages = dlqRepository.findMessagesSince(queueName, 
            Instant.now().minus(period));

        Map<String, Long> errorsByType = messages.stream()
            .collect(groupingBy(
                msg -> msg.getLastFailureType(),
                counting()
            ));

        Map<String, Long> errorsByHour = messages.stream()
            .collect(groupingBy(
                msg -> getHourBucket(msg.getLastFailureTime()),
                counting()
            ));

        return DlqAnalysisReport.builder()
            .queueName(queueName)
            .analysisPeriod(period)
            .totalMessages(messages.size())
            .errorsByType(errorsByType)
            .errorsByHour(errorsByHour)
            .topFailureReasons(getTopFailureReasons(messages, 5))
            .recommendations(generateRecommendations(errorsByType))
            .build();
    }

    private List<String> generateRecommendations(Map<String, Long> errorsByType) {
        List<String> recommendations = new ArrayList<>();

        if (errorsByType.getOrDefault("ValidationException", 0L) > 10) {
            recommendations.add("High validation errors - check input data quality");
        }

        if (errorsByType.getOrDefault("TimeoutException", 0L) > 5) {
            recommendations.add("Timeout issues - consider increasing timeout values or improving downstream service performance");
        }

        if (errorsByType.getOrDefault("ConnectionException", 0L) > 3) {
            recommendations.add("Connection issues - verify network connectivity and service availability");
        }

        return recommendations;
    }
}

2. Automated DLQ Recovery

@Component
@EnableScheduling
public class DlqRecoveryScheduler {
    private final DlqRecoveryService recoveryService;
    private final DlqAnalysisService analysisService;

    @Scheduled(fixedDelay = 3600000) // Every hour
    public void performAutomaticRecovery() {
        // Only attempt recovery for specific error types
        Set<String> recoverableErrors = Set.of(
            "TimeoutException",
            "ConnectionException", 
            "ServiceUnavailableException"
        );

        List<String> queues = List.of("contact-updates", "notification-delivery");

        for (String queue : queues) {
            try {
                DlqRecoveryRequest request = DlqRecoveryRequest.builder()
                    .queueName(queue)
                    .errorTypes(recoverableErrors)
                    .maxAge(Duration.ofHours(24)) // Only try recent messages
                    .batchSize(50)
                    .build();

                RecoveryResult result = recoveryService.reprocessMessages(request);

                log.info("DLQ recovery completed for queue {}: {} succeeded, {} failed",
                        queue, result.getSuccessCount(), result.getFailureCount());

            } catch (Exception e) {
                log.error("DLQ recovery failed for queue {}: {}", queue, e.getMessage());
            }
        }
    }

    @Scheduled(cron = "0 0 8 * * MON") // Every Monday at 8 AM
    public void generateWeeklyDlqReport() {
        List<String> queues = List.of("contact-updates", "notification-delivery");

        for (String queue : queues) {
            DlqAnalysisReport report = analysisService.analyzeDlqMessages(
                queue, Duration.ofDays(7)
            );

            if (report.getTotalMessages() > 0) {
                notificationService.sendDlqWeeklyReport(report);
            }
        }
    }
}

3. DLQ Monitoring and Alerting

@Component
public class DlqMonitoringService {
    private final MeterRegistry meterRegistry;
    private final AlertingService alertingService;

    public void recordDlqMessage(String queueName, String errorType) {
        Counter.builder("dlq_messages_total")
            .tag("queue", queueName)
            .tag("error_type", errorType)
            .register(meterRegistry)
            .increment();

        // Check if we need to trigger alerts
        checkAlertThresholds(queueName, errorType);
    }

    private void checkAlertThresholds(String queueName, String errorType) {
        // Alert on high DLQ volume
        long recentDlqCount = getDlqCountInLastHour(queueName);
        if (recentDlqCount > 100) {
            alertingService.sendAlert(
                AlertLevel.HIGH,
                "High DLQ volume detected",
                String.format("Queue %s has %d messages in DLQ in last hour", 
                             queueName, recentDlqCount)
            );
        }

        // Alert on new error types
        if (isNewErrorType(queueName, errorType)) {
            alertingService.sendAlert(
                AlertLevel.MEDIUM,
                "New DLQ error type detected",
                String.format("New error type '%s' in queue %s DLQ", 
                             errorType, queueName)
            );
        }
    }

    @EventListener
    public void handleDlqMessage(DlqMessageEvent event) {
        recordDlqMessage(
            event.getDlqMessage().getOriginalQueue(),
            event.getDlqMessage().getLastFailureType()
        );
    }
}

Common Pitfalls

1. Infinite DLQ Loops

Problem: DLQ processing failures create loops where messages bounce between queues
Solution: Implement DLQ for DLQ processing and ultimate failure handling

2. DLQ Storage Overflow

Problem: Accumulated DLQ messages consume excessive storage without cleanup
Solution: Implement retention policies and automated cleanup procedures

3. Poor Error Classification

Problem: Retryable errors sent to DLQ immediately, or permanent errors retried infinitely
Solution: Implement proper exception classification and retry policies

4. Missing DLQ Monitoring

Problem: DLQ messages accumulate without visibility or alerting
Solution: Implement comprehensive DLQ monitoring and automated analysis

5. Inadequate Recovery Procedures

Problem: No systematic approach to reprocessing DLQ messages after fixes
Solution: Develop automated and manual recovery procedures with proper testing

Integration in Distributed Systems

In distributed integration scenarios, Dead Letter Queue provides:

Event-Driven Microservices

@EventListener
@DlqEnabled(maxRetries = 3, dlqName = "contact.updates.dlq")
public void handleContactUpdateEvent(ContactUpdateEvent event) {
    contactService.processUpdate(event);
}

API Integration Failures

@Service
public class ExternalApiIntegrationService {

    @DlqOnFailure(
        exceptions = {ApiException.class, TimeoutException.class},
        maxRetries = 5,
        dlqTopic = "api.integration.failures"
    )
    public void syncWithExternalSystem(ContactData contactData) {
        externalApiClient.updateContact(contactData);
    }
}

Batch Processing Failures

@BatchProcessor
@DlqConfiguration(
    dlqName = "batch.processing.failures",
    retentionDays = 30
)
public void processBatchUpdate(List<ContactUpdate> updates) {
    for (ContactUpdate update : updates) {
        try {
            processUpdate(update);
        } catch (Exception e) {
            sendToDlq(update, e);
        }
    }
}

Conclusion

The Dead Letter Queue pattern is essential for building resilient message-driven systems that can gracefully handle processing failures while maintaining data integrity. It provides:

• Data Preservation: Ensures no messages are lost due to processing failures
• System Protection: Prevents poison messages from affecting healthy processing
• Operational Visibility: Centralizes failure analysis and recovery capabilities
• Recovery Mechanisms: Enables systematic reprocessing after issue resolution

When properly implemented with appropriate monitoring, analysis, and recovery procedures, the Dead Letter Queue pattern significantly improves system reliability and operational efficiency in distributed architectures.

References

• Enterprise Integration Patterns - Dead Letter Channel
• Amazon SQS Dead Letter Queues
• RabbitMQ Dead Letter Exchanges
• Apache Kafka Dead Letter Topic Pattern