RabbitMQ Plugin

Monitor RabbitMQ message broker with comprehensive metrics covering queues, messages, connections, channels, and resource usage.

Overview

The RabbitMQ plugin collects detailed metrics from RabbitMQ Management API including:

• Message Statistics - Ready messages, unacknowledged messages, total messages
• Queue Metrics - Queue count, queue depth, consumer distribution
• Message Rates - Publish rate, deliver rate, acknowledgment rate
• Connection Metrics - Active connections, channels, consumers
• Resource Usage - Memory usage, disk free space, file descriptors, sockets
• Cluster Health - Node status, alarms, uptime

Requirements

RabbitMQ Version

• Minimum: RabbitMQ 3.7
• Recommended: RabbitMQ 3.11 or later
• Tested with: RabbitMQ 3.9, 3.10, 3.11, 3.12

RabbitMQ Management Plugin

Required: Management plugin must be enabled

Check if enabled:

sudo rabbitmq-plugins list | grep management

Enable if missing:

sudo rabbitmq-plugins enable rabbitmq_management
sudo systemctl restart rabbitmq-server

Python Dependencies

pip install requests>=2.28.0

Auto-installed when using PLUGINS=rabbitmq during agent installation.

API Access

The agent needs HTTP access to RabbitMQ Management API (default port 15672).

Configuration

Basic Configuration

plugins:
  rabbitmq:
    enabled: true
    host: localhost
    port: 15672
    username: guest
    password: guest

With Custom User

plugins:
  rabbitmq:
    enabled: true
    host: localhost
    port: 15672
    username: monitor
    password: your-secure-password

With HTTPS

plugins:
  rabbitmq:
    enabled: true
    host: rabbitmq.example.com
    port: 15671
    username: monitor
    password: your-password
    use_ssl: true
    verify_ssl: true

All Configuration Options

plugins:
  rabbitmq:
    enabled: true                      # Enable/disable plugin
    host: localhost                    # RabbitMQ host
    port: 15672                        # Management API port (15672=HTTP, 15671=HTTPS)
    username: guest                    # Management username
    password: guest                    # Management password
    vhost: /                           # Virtual host (default: /)
    use_ssl: false                     # Use HTTPS (default: false)
    verify_ssl: true                   # Verify SSL certificates
    timeout: 10                        # Request timeout (seconds)

Environment Variables

Configuration can be overridden with environment variables:

export RABBITMQ_HOST="localhost"
export RABBITMQ_PORT="15672"
export RABBITMQ_USERNAME="monitor"
export RABBITMQ_PASSWORD="password"

RabbitMQ Setup

Installation

Ubuntu/Debian:

# Add RabbitMQ repository
curl -1sLf 'https://dl.cloudsmith.io/public/rabbitmq/rabbitmq-server/setup.deb.sh' | sudo bash

# Install RabbitMQ
sudo apt-get install rabbitmq-server

# Start service
sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

CentOS/RHEL:

# Add RabbitMQ repository
curl -1sLf 'https://dl.cloudsmith.io/public/rabbitmq/rabbitmq-server/setup.rpm.sh' | sudo bash

# Install RabbitMQ
sudo yum install rabbitmq-server

# Start service
sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

Enable Management Plugin

# Enable management plugin
sudo rabbitmq-plugins enable rabbitmq_management

# Restart RabbitMQ
sudo systemctl restart rabbitmq-server

Verify management API is accessible:

curl http://localhost:15672/api/overview

Create Monitoring User

Create dedicated monitoring user:

# Create user
sudo rabbitmqctl add_user monitor secure-password

# Set tags (monitoring tag gives read-only access)
sudo rabbitmqctl set_user_tags monitor monitoring

# Grant permissions (read-only on all resources)
sudo rabbitmqctl set_permissions -p / monitor "^$" "^$" ".*"

Or use guest user (not recommended for production):

Default credentials:

• Username: guest
• Password: guest
• Note: guest user can only access from localhost by default

User Tags and Permissions

Monitoring tag provides read-only access to management API:

sudo rabbitmqctl set_user_tags monitor monitoring

Required permissions:

• configure: ^$ (no configure permissions)
• write: ^$ (no write permissions)
• read: .* (read all resources)

sudo rabbitmqctl set_permissions -p / monitor "^$" "^$" ".*"

Enable Remote Management API Access

By default, management API only listens on localhost.

Edit RabbitMQ configuration:

sudo nano /etc/rabbitmq/rabbitmq.conf

Add:

# Listen on all interfaces
management.tcp.ip = 0.0.0.0

Or use environment variable:

sudo nano /etc/rabbitmq/rabbitmq-env.conf

# Add:
RABBITMQ_MANAGEMENT_LISTENER_IP=0.0.0.0

Restart RabbitMQ:

sudo systemctl restart rabbitmq-server

Security note: Only expose management API to trusted networks. Use firewall rules.

Collected Metrics

Message Metrics

Queue Metrics

Connection Metrics

Resource Metrics

Node Metrics

Dashboard Metrics

The StatusRadar dashboard displays:

Overview Card

• Messages Ready - Queued messages waiting for delivery
• Publish Rate - Messages published per second
• Queue Count - Total number of queues
• Memory Used - Memory utilization vs limit
• Connections - Active client connections
• Consumers - Active message consumers

Messages Over Time Chart

• Messages ready
• Messages unacknowledged
• Total messages trend

Message Rates Chart

• Publish rate (msg/s)
• Deliver rate (msg/s)
• Acknowledgment rate (msg/s)

Memory Usage Chart

• Memory used over time
• Memory limit threshold

Connections & Queues Chart

• Active connections
• Active consumers
• Queue count
• Channel count

Server Information Table

• Node name and uptime
• Message statistics
• Queue metrics
• Connection and channel counts
• Resource usage (memory, disk, file descriptors, sockets)
• Alarm status

Installation

Quick Install

PLUGINS='rabbitmq' \
TOKEN='your-agent-token' \
RABBITMQ_USERNAME='monitor' \
RABBITMQ_PASSWORD='your-password' \
bash -c "$(curl -sL https://statusradar.dev/install-agent.sh)"

Install on Existing Agent

1. Enable RabbitMQ management plugin (see above)

2. Configure agent:

   sudo nano /opt/statusradar/config/agent.yaml

   Add:

   plugins:
     rabbitmq:
       enabled: true
       host: localhost
       port: 15672
       username: monitor
       password: your-secure-password

3. Restart agent:

   sudo systemctl restart statusradar-agent

4. Verify:

   sudo journalctl -u statusradar-agent -n 50 --no-pager | grep rabbitmq

   Expected:

   INFO: Plugin rabbitmq: Metrics collected successfully
   INFO: Plugin rabbitmq: 5 queues, 123 messages ready

Testing

Manual Plugin Test

cd /opt/statusradar
python3 plugins/rabbitmq_plugin.py

Expected Output:

Plugin: rabbitmq
Enabled: True
Available: True

Collecting metrics...
{
  "node_name": "rabbit@localhost",
  "uptime_seconds": 86400,
  "messages_ready": 123,
  "messages_unacknowledged": 45,
  "messages_total": 168,
  "queue_count": 5,
  "publish_rate": 12.5,
  "deliver_rate": 11.8,
  "ack_rate": 11.8,
  "connections_total": 8,
  "channels_total": 12,
  "consumers_total": 10,
  "memory_used_mb": 145.6,
  "memory_limit_mb": 1024.0,
  "disk_free_gb": 25.3,
  "disk_free_alarm": 0,
  "fd_used": 45,
  "fd_total": 1024,
  "sockets_used": 12,
  "sockets_total": 943
}

Test Management API

# Get overview
curl -u monitor:password http://localhost:15672/api/overview

# Get queues
curl -u monitor:password http://localhost:15672/api/queues

# Get connections
curl -u monitor:password http://localhost:15672/api/connections

Access Management Web UI

Open browser:

http://localhost:15672

Login with credentials (default: guest/guest)

Troubleshooting

Plugin Not Collecting Metrics

Check 1: Is RabbitMQ running?

sudo systemctl status rabbitmq-server

Check 2: Is management plugin enabled?

sudo rabbitmq-plugins list | grep management
# Should show: [E*] rabbitmq_management

Check 3: Can agent access management API?

curl -u monitor:password http://localhost:15672/api/overview

Check 4: Check agent logs

sudo journalctl -u statusradar-agent -n 100 --no-pager | grep rabbitmq

Common Errors

"Management plugin not enabled"

Error:

ERROR: Plugin rabbitmq: HTTP 404 - management plugin not enabled

Solution:

sudo rabbitmq-plugins enable rabbitmq_management
sudo systemctl restart rabbitmq-server

"Authentication failed"

Error:

ERROR: Plugin rabbitmq: HTTP 401 - Authentication failed

Causes:

1. Wrong username/password
2. User doesn't exist
3. User lacks permissions

Solution:

# Verify user exists
sudo rabbitmqctl list_users

# Recreate user
sudo rabbitmqctl delete_user monitor
sudo rabbitmqctl add_user monitor secure-password
sudo rabbitmqctl set_user_tags monitor monitoring
sudo rabbitmqctl set_permissions -p / monitor "^$" "^$" ".*"

"Connection refused"

Error:

ERROR: Plugin rabbitmq: Connection refused

Causes:

1. RabbitMQ not running
2. Management API not listening on expected port
3. Firewall blocking connection

Solution:

# Check RabbitMQ is running
sudo systemctl status rabbitmq-server

# Check port
sudo netstat -tlnp | grep 15672

# Check management listener
sudo rabbitmqctl status | grep listeners

"Guest access refused"

Error:

ERROR: Plugin rabbitmq: HTTP 401 - Access refused for user 'guest'

Cause: guest user can only access from localhost by default

Solutions:

Option 1: Use localhost (if agent runs on same server):

plugins:
  rabbitmq:
    host: localhost  # or 127.0.0.1

Option 2: Enable guest remote access (not recommended):

sudo nano /etc/rabbitmq/rabbitmq.conf

# Add:
loopback_users = none

Option 3: Create dedicated user (recommended):

sudo rabbitmqctl add_user monitor password
sudo rabbitmqctl set_user_tags monitor monitoring
sudo rabbitmqctl set_permissions -p / monitor "^$" "^$" ".*"

Performance Impact

On RabbitMQ

Minimal impact:

• Management API returns pre-calculated statistics
• No message processing or routing impact
• Response time: < 50ms

Benchmark:

• Overhead: < 0.1% CPU
• No measurable performance degradation

On Agent

Resource usage:

• Memory: +12 MB
• CPU: +2% during collection
• Network: +2 KB per collection

Collection time: 0.1-0.5 seconds

Use Cases

1. Queue Depth Monitoring

Monitor:

• Messages ready
• Messages unacknowledged
• Queue growth rate

Alert on:

• Messages ready > 10,000 (queue backup)
• Messages growing rapidly
• No consumers on queues

2. Consumer Monitoring

Monitor:

• Consumer count per queue
• Deliver rate vs publish rate
• Acknowledgment rate

Alert on:

• Consumers = 0 (no processing)
• Deliver rate < publish rate (falling behind)
• Ack rate < deliver rate (slow processing)

3. Connection Monitoring

Monitor:

• Active connections
• Channel count
• Connection creation rate

Alert on:

• Connections approaching limit
• Connection churn (many open/close)
• Channels without consumers

4. Resource Monitoring

Monitor:

• Memory usage vs limit
• Disk free space
• File descriptor usage
• Socket usage

Alert on:

• Memory > 80% of limit
• Disk alarm active
• File descriptors > 90% of limit

5. Message Rate Monitoring

Monitor:

• Publish rate
• Deliver rate
• Ack rate ratio

Optimize:

• Consumer count
• Prefetch settings
• Queue configurations

Best Practices

1. Set Resource Limits

Memory limit (vm_memory_high_watermark):

sudo nano /etc/rabbitmq/rabbitmq.conf

# Add:
vm_memory_high_watermark.relative = 0.4  # 40% of system RAM

Disk free space limit:

disk_free_limit.absolute = 10GB

2. Monitor Memory Alarms

When memory alarm triggers:

• Publishers are blocked
• Messages cannot be published
• Consumers continue processing

Check alarm status:

sudo rabbitmqctl status | grep alarms

3. Tune File Descriptors

Increase FD limit:

sudo nano /etc/systemd/system/rabbitmq-server.service.d/limits.conf

# Add:
[Service]
LimitNOFILE=65536

sudo systemctl daemon-reload
sudo systemctl restart rabbitmq-server

4. Monitor Queue Depth

Healthy queue depth: < 1000 messages per queue

If queues growing:

• Add more consumers
• Increase prefetch count
• Optimize consumer processing
• Check for dead letter queues

5. Use Monitoring Tag

Always create monitoring user with monitoring tag (read-only):

sudo rabbitmqctl set_user_tags monitor monitoring

Never use administrator tag for monitoring - excessive privileges.

6. Enable Heartbeats

Configure heartbeat interval:

heartbeat = 60

Helps detect and clean up dead connections.

RabbitMQ Performance Tuning

Consumer Optimization

Set appropriate prefetch count:

channel.basic_qos(prefetch_count=10)

• Too low → underutilized consumers
• Too high → memory issues

Queue Configuration

Durable queues:

channel.queue_declare(queue='tasks', durable=True)

• Durable: Survive restarts (slower)
• Transient: Faster, lost on restart

Lazy queues (for large queues):

rabbitmqctl set_policy lazy-queue "^lazy-" '{"queue-mode":"lazy"}' --apply-to queues

Cluster Configuration

For high availability:

# Set policy for mirrored queues
rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all"}'

Advanced Configuration

Multiple Virtual Hosts

Monitor different virtual hosts:

plugins:
  rabbitmq_main:
    enabled: true
    host: localhost
    vhost: /
    username: monitor
    password: password

  rabbitmq_staging:
    enabled: true
    host: localhost
    vhost: /staging
    username: monitor
    password: password

RabbitMQ Cluster

Monitor each node separately:

plugins:
  rabbitmq_node1:
    enabled: true
    host: rabbit1.example.com
    port: 15672
    username: monitor
    password: password

  rabbitmq_node2:
    enabled: true
    host: rabbit2.example.com
    port: 15672
    username: monitor
    password: password

Docker Container

Monitor RabbitMQ in Docker:

plugins:
  rabbitmq:
    enabled: true
    host: rabbitmq-container
    port: 15672
    username: guest
    password: guest

Docker run:

docker run -d --name rabbitmq \
  -p 5672:5672 \
  -p 15672:15672 \
  rabbitmq:3-management

Example Configurations

Basic Production

plugins:
  rabbitmq:
    enabled: true
    host: localhost
    port: 15672
    username: monitor
    password: ${RABBITMQ_PASSWORD}

With HTTPS

plugins:
  rabbitmq:
    enabled: true
    host: rabbitmq.internal
    port: 15671
    username: monitor
    password: ${RABBITMQ_PASSWORD}
    use_ssl: true
    verify_ssl: true

High-Availability Cluster

plugins:
  rabbitmq_node1:
    enabled: true
    host: rabbit-node1.internal
    port: 15672
    username: monitor
    password: ${RABBITMQ_PASSWORD}

  rabbitmq_node2:
    enabled: true
    host: rabbit-node2.internal
    port: 15672
    username: monitor
    password: ${RABBITMQ_PASSWORD}

  rabbitmq_node3:
    enabled: true
    host: rabbit-node3.internal
    port: 15672
    username: monitor
    password: ${RABBITMQ_PASSWORD}

Limitations

Current Limitations

1. No per-queue details - Only aggregate statistics
2. No per-exchange metrics - Exchange-level monitoring not available
3. No consumer details - Individual consumer metrics not collected

Scalability

Tested with:

• 1000+ queues
• 10,000+ messages per second
• 500+ connections

Performance:

• API response time increases slightly with queue count
• Recommended: < 1000 queues for optimal performance

Monitoring Checklist

Critical Metrics:

1. Messages ready > 10,000
2. Memory alarm active
3. Disk alarm active
4. File descriptors > 90%

Important Metrics: 5. Consumer count = 0 6. Publish rate >> deliver rate 7. Connection growth 8. Channel leaks

Alert Thresholds

# Recommended thresholds
messages_ready: > 10000
memory_usage_percent: > 80
disk_free_alarm: == 1
fd_usage_percent: > 90
consumers_total: == 0  # For queues that should have consumers

Next Steps

• View all plugins
• System Requirements
• Agent Configuration Guide
• Troubleshooting Guide