Fix RabbitMQ Consumer Not Receiving Messages

What's Actually Happening

RabbitMQ consumer is connected but not receiving messages. Messages are published to the exchange but don't reach the consumer application.

The Error You'll See

```bash $ rabbitmqctl list_consumers

# Consumer registered but no messages delivered ```

Queue has messages but consumer idle:

```bash $ rabbitmqctl list_queues name consumers messages

my-queue 1 150 # 150 messages, 1 consumer, not consuming ```

Consumer log shows connection:

Consumer connected to queue: my-queue
# But no message processing logs

Messages in queue unprocessed:

```bash $ rabbitmqctl list_queues name messages_ready messages_unacked

my-queue 150 0 # Messages ready, none being processed ```

Why This Happens

1. 1.Queue not bound to exchange - Queue missing binding to exchange
2. 2.Wrong routing key - Binding key doesn't match message routing key
3. 3.Consumer on wrong queue - Consumer listening to different queue
4. 4.Prefetch too high - Messages stuck in unacknowledged state
5. 5.Consumer in error state - Consumer connection issue
6. 6.Exchange type mismatch - Wrong exchange type for routing

Step 1: Check Queue and Exchange Status

```bash # List queues: rabbitmqctl list_queues name consumers messages

# List exchanges: rabbitmqctl list_exchanges name type

# List bindings: rabbitmqctl list_bindings source_name destination_name routing_key

# Check specific queue: rabbitmqctl list_queues name messages_ready messages_unacked consumers

# Check queue arguments: rabbitmqctl list_queues name arguments

# Via rabbitmqadmin: rabbitmqadmin list queues rabbitmqadmin list exchanges rabbitmqadmin list bindings

# Via Management API: curl -u guest:guest http://localhost:15672/api/queues curl -u guest:guest http://localhost:15672/api/exchanges curl -u guest:guest http://localhost:15672/api/bindings

# Via Management UI: # http://localhost:15672 -> Queues tab ```

Step 2: Check Queue Binding

```bash # List bindings for queue: rabbitmqctl list_bindings | grep my-queue

# Expected output shows source exchange, destination queue, routing key: # exchange_name queue_name routing_key

# Check binding exists: rabbitmqctl list_bindings source_name destination_name routing_key | grep -E "source_exchange.*my-queue"

# If missing, create binding: rabbitmqadmin declare binding source=my-exchange destination=my-queue routing_key=my.key

# Or via API: curl -u guest:guest -X POST \ -H "Content-Type: application/json" \ -d '{"routing_key":"my.key"}' \ http://localhost:15672/api/bindings/%2f/e/my-exchange/q/my-queue

# In code (Python/pika): channel.queue_bind( queue='my-queue', exchange='my-exchange', routing_key='my.key' ) ```

Step 3: Verify Exchange Routing

```bash # Check exchange type: rabbitmqctl list_exchanges name type

# Exchange types: # direct - Messages routed by exact routing key match # topic - Messages routed by pattern matching # fanout - Messages routed to all bound queues # headers - Messages routed by headers

# Test routing by publishing test message: rabbitmqadmin publish exchange=my-exchange routing_key=my.key payload="test message"

# Check if message reached queue: rabbitmqctl list_queues name messages

# For topic exchange, verify routing key pattern: # Pattern: "*.error" matches "app.error", "system.error" # Pattern: "#.error" matches "error", "app.error", "app.system.error"

# Use rabbitmq_tracing plugin for debugging: rabbitmq-plugins enable rabbitmq_tracing

# Or use firehose: rabbitmq-plugins enable rabbitmq_firehose ```

Step 4: Check Consumer Configuration

```python # Python/pika consumer example:

import pika

connection = pika.BlockingConnection( pika.ConnectionParameters('localhost') ) channel = connection.channel()

# Consumer settings: channel.basic_qos(prefetch_count=1) # Important for fair dispatch

# Check consumer tag: def callback(ch, method, properties, body): print(f"Received: {body}") ch.basic_ack(delivery_tag=method.delivery_tag)

# Start consuming: channel.basic_consume( queue='my-queue', on_message_callback=callback, auto_ack=False # Manual acknowledgment )

print('Waiting for messages...') channel.start_consuming()

# Common issues: # - Wrong queue name # - auto_ack=True when expecting manual ack # - Missing basic_qos causes uneven distribution ```

```java // Java consumer example: ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel();

// Set prefetch: channel.basicQos(1);

// Consumer: DeliverCallback deliverCallback = (consumerTag, delivery) -> { String message = new String(delivery.getBody(), "UTF-8"); System.out.println("Received: " + message); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); };

channel.basicConsume("my-queue", false, deliverCallback, consumerTag -> {}); ```

Step 5: Check Prefetch Settings

```bash # Prefetch determines how many messages consumer can have unacked

# Check consumer prefetch: rabbitmqctl list_channels prefetch_count

# If prefetch too high, messages stuck: # Consumer has many unacked messages, not processing new ones

# Set appropriate prefetch: # In code: channel.basic_qos(prefetch_count=10)

# For multiple consumers, use lower prefetch (1-10) # For single consumer, higher is OK (10-50)

# Check unacknowledged messages: rabbitmqctl list_queues name messages_unacked

# If unacked messages high and not decreasing: # Consumer might be stuck

# Reset by reconnection or cancel consumer: # Via API: curl -u guest:guest -X DELETE \ http://localhost:15672/api/consumers/%2f/consumer-tag ```

Step 6: Check Message Flow

```bash # Enable message tracing: rabbitmq-plugins enable rabbitmq_tracing

# Configure trace: curl -u guest:guest -X PUT \ -H "Content-Type: application/json" \ -d '{"format":"text","pattern":"#"}' \ http://localhost:15672/api/tracing/my-trace

# Check trace file: cat /var/log/rabbitmq/tracing/my-trace.log

# Use queue statistics: rabbitmqctl list_queues name messages_ready messages_unacked

# Monitor in real-time: watch -n 1 'rabbitmqctl list_queues name messages_ready messages_unacked consumers'

# Check message rates: curl -u guest:guest http://localhost:15672/api/queues/%2f/my-queue | jq '.message_stats'

# Check delivery rate: curl -u guest:guest http://localhost:15672/api/queues/%2f/my-queue | jq '.message_stats.deliver_get_details' ```

Step 7: Verify Consumer Connection

```bash # List connections: rabbitmqctl list_connections

# List channels: rabbitmqctl list_channels

# Check consumer details: rabbitmqctl list_consumers

# Output: queue_name channel_pid consumer_tag prefetch_count

# Check channel is active: rabbitmqctl list_channels pid user consumer_count

# Check connection state: curl -u guest:guest http://localhost:15672/api/connections | jq '.[].state'

# If connection closed, check client logs

# Check network between consumer and RabbitMQ: # From consumer host: telnet rabbitmq-host 5672 nc -zv rabbitmq-host 5672

# Check firewall allows AMQP (5672) and Management (15672) ```

Step 8: Check Dead Letter Queue

```bash # Check if messages going to DLQ:

# List DLQ if exists: rabbitmqctl list_queues name | grep dlq

# Check queue arguments for DLX: rabbitmqctl list_queues name arguments

# Look for x-dead-letter-exchange argument

# Check DLX binding: rabbitmqctl list_bindings | grep dlx

# If messages in DLQ: rabbitmqctl list_queues name messages | grep dlq

# Requeue from DLQ: rabbitmqadmin publish exchange=dlx-exchange routing_key=original.key payload="message"

# Or via shovel plugin: rabbitmq-plugins enable rabbitmq_shovel

# Check why messages going to DLQ: # - Rejected (basic.reject/basic.nack with requeue=false) # - Expired (TTL) # - Queue overflow (max-length) ```

Step 9: Check Message TTL and Queue Settings

```bash # Check queue TTL settings: rabbitmqctl list_queues name arguments

# x-message-ttl: Message TTL in ms # x-expires: Queue auto-delete timeout # x-max-length: Maximum messages in queue # x-max-length-bytes: Maximum bytes in queue

# If TTL expired, messages deleted before consumption: # Check TTL is appropriate

# Check queue arguments: curl -u guest:guest http://localhost:15672/api/queues/%2f/my-queue | jq '.arguments'

# If max-length reached, new messages rejected or old ones deleted: # Check x-overflow setting: "drop-head" or "reject-publish"

# If queue expired: # Queue deleted when no consumers for x-expires duration

# Recreate queue if needed: rabbitmqadmin delete queue name=my-queue rabbitmqadmin declare queue name=my-queue durable=true ```

Step 10: RabbitMQ Consumer Verification Script

```bash # Create verification script: cat << 'EOF' > /usr/local/bin/check-rabbitmq-consumer.sh #!/bin/bash

QUEUE=$1

echo "=== RabbitMQ Overview ===" rabbitmqctl status | head -20

echo "" echo "=== Queues with Messages ===" rabbitmqctl list_queues name messages consumers messages_ready messages_unacked

if [ -n "$QUEUE" ]; then echo "" echo "=== Queue: $QUEUE Details ===" rabbitmqctl list_queues name messages consumers messages_ready messages_unacked | grep $QUEUE

echo "" echo "=== Bindings for $QUEUE ===" rabbitmqctl list_bindings | grep $QUEUE

echo "" echo "=== Consumers of $QUEUE ===" rabbitmqctl list_consumers | grep $QUEUE fi

echo "" echo "=== Exchanges ===" rabbitmqctl list_exchanges name type | grep -v "^$"

echo "" echo "=== Bindings Summary ===" rabbitmqctl list_bindings | head -20

echo "" echo "=== Connections ===" rabbitmqctl list_connections user peer_host peer_port state

echo "" echo "=== Channels ===" rabbitmqctl list_channels user consumer_count messages_unacked

echo "" echo "=== Test Message ===" echo "Publish test message with:" echo "rabbitmqadmin publish exchange=my-exchange routing_key=my.key payload='test'" EOF

chmod +x /usr/local/bin/check-rabbitmq-consumer.sh

# Usage: /usr/local/bin/check-rabbitmq-consumer.sh my-queue

# Quick test: alias rabbitmq-check='rabbitmqctl list_queues name messages consumers' ```

RabbitMQ Consumer Checklist

Verify the Fix

```bash # After fixing consumer issue

# 1. Check queue binding rabbitmqctl list_bindings | grep my-queue // Binding to exchange exists

# 2. Publish test message rabbitmqadmin publish exchange=my-exchange routing_key=my.key payload="test" // Message published

# 3. Check consumer receives # In consumer logs // Message received and processed

# 4. Check queue messages rabbitmqctl list_queues name messages // Messages decreasing

# 5. Monitor consumption watch rabbitmqctl list_queues name messages // Messages being consumed

# 6. Check message stats curl -u guest:guest http://localhost:15672/api/queues/%2f/my-queue | jq .message_stats // deliver_get > 0 ```

Related Issues

• [Fix RabbitMQ Connection Refused](/articles/fix-rabbitmq-connection-refused)
• [Fix RabbitMQ Queue Full](/articles/fix-rabbitmq-queue-full)
• [Fix RabbitMQ Publisher Not Working](/articles/fix-rabbitmq-publisher-not-working)