---
title: RabbitMQ OpenTelemetry metrics reference
source: https://docs.newrelic.com/docs/opentelemetry/integrations/rabbitmq/metrics-reference
---

This comprehensive reference documents all RabbitMQ metrics collected by the OpenTelemetry Collector integration. Each metric includes detailed descriptions and practical NRQL query examples.

> #### 💡 TIP
>
> **New to RabbitMQ monitoring?** Start with the [overview guide](https://docs.newrelic.com/docs/opentelemetry/integrations/rabbitmq/overview) to understand the integration architecture and deployment options.

## Understanding RabbitMQ metrics [#overview]

The RabbitMQ OpenTelemetry integration collects metrics through the RabbitMQ management API, providing comprehensive visibility into your message broker's health and performance.

**Metric categories:**

-   **Node metrics** - Node-level resource usage including memory, disk, file descriptors, and Erlang VM statistics
-   **Queue metrics** - Message counts, consumer activity, and queue-level throughput per queue
-   **Message metrics** - Message publishing, delivery, and acknowledgment rates
-   **I/O metrics** - Disk read/write operations and latency for message persistence
-   **Connection metrics** - Connection and channel lifecycle events

**Common metric attributes:**

All metrics include these attributes for filtering and grouping:

-   `instrumentation.provider = 'opentelemetry'` - Identifies metrics from this integration
-   `rabbitmq.deployment.name` - Your deployment identifier
-   `rabbitmq.server.endpoint` - Management API endpoint
-   `host.name` - Hostname where RabbitMQ is running

> #### ⚠️ IMPORTANT
>
> When querying RabbitMQ metrics, always include `instrumentation.provider = 'opentelemetry'` in your WHERE clause to ensure you're only getting data from this integration.

## Node resource metrics [#node-resource-metrics]

Node resource metrics track memory, disk, file descriptors, and Erlang VM resources for each RabbitMQ node.

### Memory metrics

**rabbitmq.node.mem_used**

**Type**: Gauge  
**Unit**: Bytes  
**Description**: Total memory used by the RabbitMQ node in bytes.

**Use case**: Monitor node memory consumption to prevent out-of-memory conditions.

**NRQL examples:**

View current memory usage:

```sql
SELECT latest(rabbitmq.node.mem_used) / 1024 / 1024 AS 'Memory Used (MB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_used'
FACET host.name
```

Track memory trends:

```sql
SELECT latest(rabbitmq.node.mem_used) / 1024 / 1024 AS 'Memory Used (MB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_used'
FACET host.name
TIMESERIES
```

Memory utilization percentage:

```sql
SELECT 
  (latest(rabbitmq.node.mem_used) / latest(rabbitmq.node.mem_limit)) * 100 AS 'Memory Utilization %'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
TIMESERIES
```

**rabbitmq.node.mem_limit**

**Type**: Gauge  
**Unit**: Bytes  
**Description**: Memory limit configured for the RabbitMQ node.

**Use case**: Compare against memory used to calculate utilization and trigger alarms.

**NRQL examples:**

View memory limits:

```sql
SELECT latest(rabbitmq.node.mem_limit) / 1024 / 1024 / 1024 AS 'Memory Limit (GB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_limit'
FACET host.name
```

Memory headroom calculation:

```sql
SELECT 
  (latest(rabbitmq.node.mem_limit) - latest(rabbitmq.node.mem_used)) / 1024 / 1024 AS 'Available Memory (MB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
```

**rabbitmq.node.mem_alarm**

**Type**: Gauge  
**Unit**: Boolean (0 or 1)  
**Description**: Memory alarm status (0 = no alarm, 1 = alarm triggered).

**Use case**: Alert when memory threshold breaches occur.

**NRQL examples:**

Check alarm status:

```sql
SELECT latest(rabbitmq.node.mem_alarm) AS 'Memory Alarm'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_alarm'
FACET host.name
```

Alert on memory alarm:

```sql
SELECT latest(rabbitmq.node.mem_alarm)
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_alarm'
  AND rabbitmq.node.mem_alarm = 1
FACET host.name
```

**rabbitmq.node.mem_used_details.rate**

**Type**: Gauge  
**Unit**: Bytes per second  
**Description**: Rate of memory usage change per second.

**Use case**: Monitor memory growth rate to detect memory leaks.

**NRQL examples:**

View memory growth rate:

```sql
SELECT latest(rabbitmq.node.mem_used_details.rate) / 1024 AS 'Memory Growth Rate (KB/s)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mem_used_details.rate'
FACET host.name
TIMESERIES
```

### Disk metrics

**rabbitmq.node.disk_free**

**Type**: Gauge  
**Unit**: Bytes  
**Description**: Available disk space in bytes.

**Use case**: Monitor disk space availability to prevent disk full conditions.

**NRQL examples:**

View available disk space:

```sql
SELECT latest(rabbitmq.node.disk_free) / 1024 / 1024 / 1024 AS 'Disk Free (GB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.disk_free'
FACET host.name
```

Disk utilization percentage:

```sql
SELECT 
  ((latest(rabbitmq.node.disk_free_limit) - latest(rabbitmq.node.disk_free)) / latest(rabbitmq.node.disk_free_limit)) * 100 AS 'Disk Usage %'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
TIMESERIES
```

**rabbitmq.node.disk_free_limit**

**Type**: Gauge  
**Unit**: Bytes  
**Description**: Disk free space limit threshold.

**Use case**: Compare against disk free space to calculate utilization.

**NRQL examples:**

View disk free limit:

```sql
SELECT latest(rabbitmq.node.disk_free_limit) / 1024 / 1024 / 1024 AS 'Disk Free Limit (GB)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.disk_free_limit'
FACET host.name
```

**rabbitmq.node.disk_free_alarm**

**Type**: Gauge  
**Unit**: Boolean (0 or 1)  
**Description**: Disk free alarm status (0 = no alarm, 1 = alarm triggered).

**Use case**: Alert when disk space threshold breaches occur.

**NRQL examples:**

Check disk alarm status:

```sql
SELECT latest(rabbitmq.node.disk_free_alarm) AS 'Disk Alarm'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.disk_free_alarm'
FACET host.name
```

### File descriptor and socket metrics

**rabbitmq.node.fd_used**

**Type**: Gauge  
**Unit**: File descriptors  
**Description**: Number of file descriptors currently in use.

**Use case**: Track file descriptor usage to prevent exhaustion.

**NRQL examples:**

View file descriptor usage:

```sql
SELECT latest(rabbitmq.node.fd_used) AS 'FDs Used'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.fd_used'
FACET host.name
```

File descriptor utilization:

```sql
SELECT 
  (latest(rabbitmq.node.fd_used) / latest(rabbitmq.node.fd_total)) * 100 AS 'FD Utilization %'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
TIMESERIES
```

**rabbitmq.node.fd_total**

**Type**: Gauge  
**Unit**: File descriptors  
**Description**: Total number of file descriptors available.

**Use case**: Compare against file descriptors used to calculate utilization.

**NRQL examples:**

View file descriptor limit:

```sql
SELECT latest(rabbitmq.node.fd_total) AS 'Total FDs'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.fd_total'
FACET host.name
```

**rabbitmq.node.sockets_used**

**Type**: Gauge  
**Unit**: Sockets  
**Description**: Number of network sockets currently in use.

**Use case**: Monitor socket usage to track connection activity.

**NRQL examples:**

View socket usage:

```sql
SELECT latest(rabbitmq.node.sockets_used) AS 'Sockets Used'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.sockets_used'
FACET host.name
TIMESERIES
```

Socket utilization:

```sql
SELECT 
  (latest(rabbitmq.node.sockets_used) / latest(rabbitmq.node.sockets_total)) * 100 AS 'Socket Utilization %'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
```

**rabbitmq.node.sockets_total**

**Type**: Gauge  
**Unit**: Sockets  
**Description**: Maximum number of sockets available.

**Use case**: Compare against sockets used to calculate utilization.

**NRQL examples:**

View socket limit:

```sql
SELECT latest(rabbitmq.node.sockets_total) AS 'Total Sockets'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.sockets_total'
FACET host.name
```

### Erlang VM metrics

**rabbitmq.node.proc_used**

**Type**: Gauge  
**Unit**: Processes  
**Description**: Number of Erlang processes currently in use.

**Use case**: Monitor Erlang process usage to prevent process limit exhaustion.

**NRQL examples:**

View Erlang process usage:

```sql
SELECT latest(rabbitmq.node.proc_used) AS 'Erlang Processes Used'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.proc_used'
FACET host.name
```

Process utilization:

```sql
SELECT 
  (latest(rabbitmq.node.proc_used) / latest(rabbitmq.node.proc_total)) * 100 AS 'Process Utilization %'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
TIMESERIES
```

**rabbitmq.node.proc_total**

**Type**: Gauge  
**Unit**: Processes  
**Description**: Maximum number of Erlang processes allowed.

**Use case**: Compare against processes used to calculate utilization.

**NRQL examples:**

View Erlang process limit:

```sql
SELECT latest(rabbitmq.node.proc_total) AS 'Max Erlang Processes'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.proc_total'
FACET host.name
```

**rabbitmq.node.run_queue**

**Type**: Gauge  
**Unit**: Processes  
**Description**: Number of Erlang processes waiting to run.

**Use case**: Monitor Erlang VM scheduler queue length to detect CPU saturation.

**NRQL examples:**

View run queue depth:

```sql
SELECT latest(rabbitmq.node.run_queue) AS 'Run Queue Depth'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.run_queue'
FACET host.name
TIMESERIES
```

**rabbitmq.node.processors**

**Type**: Gauge  
**Unit**: Processors  
**Description**: Number of CPU processors available to the node.

**Use case**: System resource information for capacity planning.

**NRQL examples:**

View CPU count:

```sql
SELECT latest(rabbitmq.node.processors) AS 'CPU Count'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.processors'
FACET host.name
```

**rabbitmq.node.uptime**

**Type**: Gauge  
**Unit**: Milliseconds  
**Description**: Node uptime in milliseconds.

**Use case**: Monitor node stability and detect restarts.

**NRQL examples:**

View node uptime:

```sql
SELECT latest(rabbitmq.node.uptime) / 1000 / 60 / 60 / 24 AS 'Uptime (days)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.uptime'
FACET host.name
```

Detect recent restarts:

```sql
SELECT latest(rabbitmq.node.uptime) / 1000 / 60 AS 'Uptime (minutes)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.uptime'
  AND rabbitmq.node.uptime < 3600000
FACET host.name
```

**rabbitmq.node.context_switches_details.rate**

**Type**: Gauge  
**Unit**: Switches per second  
**Description**: Rate of context switches per second.

**Use case**: Monitor Erlang VM performance and scheduler activity.

**NRQL examples:**

View context switch rate:

```sql
SELECT latest(rabbitmq.node.context_switches_details.rate) AS 'Context Switches/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.context_switches_details.rate'
FACET host.name
TIMESERIES
```

### Garbage collection metrics

**rabbitmq.node.gc_num_details.rate**

**Type**: Gauge  
**Unit**: GC runs per second  
**Description**: Rate of garbage collection runs per second.

**Use case**: Monitor GC frequency to detect memory pressure.

**NRQL examples:**

View GC rate:

```sql
SELECT latest(rabbitmq.node.gc_num_details.rate) AS 'GC Runs/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.gc_num_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.gc_bytes_reclaimed_details.rate**

**Type**: Gauge  
**Unit**: Bytes per second  
**Description**: Rate of bytes reclaimed by garbage collection per second.

**Use case**: Monitor GC efficiency and memory reclamation.

**NRQL examples:**

View GC reclamation rate:

```sql
SELECT latest(rabbitmq.node.gc_bytes_reclaimed_details.rate) / 1024 / 1024 AS 'GC Reclaimed (MB/s)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.gc_bytes_reclaimed_details.rate'
FACET host.name
TIMESERIES
```

## I/O and persistence metrics [#io-metrics]

I/O metrics track disk read/write operations and latency for message persistence.

### Disk I/O operations

**rabbitmq.node.io_read_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of I/O read operations per second.

**Use case**: Monitor disk read activity for message retrieval.

**NRQL examples:**

View read operation rate:

```sql
SELECT latest(rabbitmq.node.io_read_count_details.rate) AS 'Read Ops/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_read_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_read_bytes_details.rate**

**Type**: Gauge  
**Unit**: Bytes per second  
**Description**: Rate of bytes read per second.

**Use case**: Monitor disk read throughput.

**NRQL examples:**

View read throughput:

```sql
SELECT latest(rabbitmq.node.io_read_bytes_details.rate) / 1024 / 1024 AS 'Read Throughput (MB/s)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_read_bytes_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_read_avg_time_details.rate**

**Type**: Gauge  
**Unit**: Milliseconds  
**Description**: Average I/O read time rate.

**Use case**: Monitor read latency for performance issues.

**NRQL examples:**

View read latency:

```sql
SELECT latest(rabbitmq.node.io_read_avg_time_details.rate) AS 'Avg Read Time (ms)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_read_avg_time_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_write_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of I/O write operations per second.

**Use case**: Monitor disk write activity for message persistence.

**NRQL examples:**

View write operation rate:

```sql
SELECT latest(rabbitmq.node.io_write_count_details.rate) AS 'Write Ops/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_write_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_write_bytes_details.rate**

**Type**: Gauge  
**Unit**: Bytes per second  
**Description**: Rate of bytes written per second.

**Use case**: Monitor disk write throughput.

**NRQL examples:**

View write throughput:

```sql
SELECT latest(rabbitmq.node.io_write_bytes_details.rate) / 1024 / 1024 AS 'Write Throughput (MB/s)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_write_bytes_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_write_avg_time_details.rate**

**Type**: Gauge  
**Unit**: Milliseconds  
**Description**: Average I/O write time rate.

**Use case**: Monitor write latency for performance issues.

**NRQL examples:**

View write latency:

```sql
SELECT latest(rabbitmq.node.io_write_avg_time_details.rate) AS 'Avg Write Time (ms)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_write_avg_time_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_sync_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of I/O sync operations per second.

**Use case**: Monitor fsync frequency for durability operations.

**NRQL examples:**

View sync operation rate:

```sql
SELECT latest(rabbitmq.node.io_sync_count_details.rate) AS 'Sync Ops/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_sync_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_sync_avg_time_details.rate**

**Type**: Gauge  
**Unit**: Milliseconds  
**Description**: Average I/O sync time rate.

**Use case**: Monitor sync latency for durability performance.

**NRQL examples:**

View sync latency:

```sql
SELECT latest(rabbitmq.node.io_sync_avg_time_details.rate) AS 'Avg Sync Time (ms)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_sync_avg_time_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_seek_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of I/O seek operations per second.

**Use case**: Monitor disk seek activity.

**NRQL examples:**

View seek operation rate:

```sql
SELECT latest(rabbitmq.node.io_seek_count_details.rate) AS 'Seek Ops/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_seek_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_seek_avg_time_details.rate**

**Type**: Gauge  
**Unit**: Milliseconds  
**Description**: Average I/O seek time rate.

**Use case**: Monitor seek latency.

**NRQL examples:**

View seek latency:

```sql
SELECT latest(rabbitmq.node.io_seek_avg_time_details.rate) AS 'Avg Seek Time (ms)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_seek_avg_time_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.io_reopen_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of file reopen operations per second.

**Use case**: Monitor file handle churn.

**NRQL examples:**

View reopen rate:

```sql
SELECT latest(rabbitmq.node.io_reopen_count_details.rate) AS 'Reopen Ops/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.io_reopen_count_details.rate'
FACET host.name
TIMESERIES
```

### Message store metrics

**rabbitmq.node.msg_store_read_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of message store read operations per second.

**Use case**: Monitor message persistence reads.

**NRQL examples:**

View message store read rate:

```sql
SELECT latest(rabbitmq.node.msg_store_read_count_details.rate) AS 'Msg Store Reads/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.msg_store_read_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.msg_store_write_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of message store write operations per second.

**Use case**: Monitor message persistence writes.

**NRQL examples:**

View message store write rate:

```sql
SELECT latest(rabbitmq.node.msg_store_write_count_details.rate) AS 'Msg Store Writes/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.msg_store_write_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.queue_index_read_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of queue index read operations per second.

**Use case**: Monitor queue index reads.

**NRQL examples:**

View queue index read rate:

```sql
SELECT latest(rabbitmq.node.queue_index_read_count_details.rate) AS 'Queue Index Reads/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.queue_index_read_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.queue_index_write_count_details.rate**

**Type**: Gauge  
**Unit**: Operations per second  
**Description**: Rate of queue index write operations per second.

**Use case**: Monitor queue index writes.

**NRQL examples:**

View queue index write rate:

```sql
SELECT latest(rabbitmq.node.queue_index_write_count_details.rate) AS 'Queue Index Writes/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.queue_index_write_count_details.rate'
FACET host.name
TIMESERIES
```

### Mnesia database metrics

**rabbitmq.node.mnesia_ram_tx_count_details.rate**

**Type**: Gauge  
**Unit**: Transactions per second  
**Description**: Rate of Mnesia RAM transactions per second.

**Use case**: Monitor database RAM transaction activity.

**NRQL examples:**

View Mnesia RAM transaction rate:

```sql
SELECT latest(rabbitmq.node.mnesia_ram_tx_count_details.rate) AS 'Mnesia RAM Tx/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mnesia_ram_tx_count_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.mnesia_disk_tx_count_details.rate**

**Type**: Gauge  
**Unit**: Transactions per second  
**Description**: Rate of Mnesia disk transactions per second.

**Use case**: Monitor database disk transaction activity.

**NRQL examples:**

View Mnesia disk transaction rate:

```sql
SELECT latest(rabbitmq.node.mnesia_disk_tx_count_details.rate) AS 'Mnesia Disk Tx/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.mnesia_disk_tx_count_details.rate'
FACET host.name
TIMESERIES
```

## Queue metrics [#queue-metrics]

Queue metrics provide insights into message flow, backlogs, and consumer activity per queue.

**rabbitmq.consumer.count**

**Type**: Gauge  
**Unit**: Consumers  
**Description**: Number of consumers connected to the queue.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Monitor consumer connections to detect disconnections.

**NRQL examples:**

View consumers per queue:

```sql
SELECT latest(rabbitmq.consumer.count) AS 'Consumers'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.consumer.count'
FACET rabbitmq.queue.name
```

Find queues with no consumers:

```sql
SELECT latest(rabbitmq.consumer.count)
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.consumer.count'
  AND rabbitmq.consumer.count = 0
FACET rabbitmq.queue.name
```

**rabbitmq.message.current (state = 'ready')**

**Type**: Gauge  
**Unit**: Messages  
**Description**: Number of messages ready to be delivered.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue
-   `state`: Message state (ready, unacknowledged)

**Use case**: Monitor queue backlog to detect message accumulation.

**NRQL examples:**

View ready messages per queue:

```sql
SELECT latest(rabbitmq.message.current) AS 'Ready Messages'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.current'
  AND state = 'ready'
FACET rabbitmq.queue.name
```

Track ready message trends:

```sql
SELECT latest(rabbitmq.message.current)
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.current'
  AND state = 'ready'
FACET rabbitmq.queue.name
TIMESERIES
```

**rabbitmq.message.current (state = 'unacknowledged')**

**Type**: Gauge  
**Unit**: Messages  
**Description**: Number of messages delivered but not yet acknowledged.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue
-   `state`: Message state (ready, unacknowledged)

**Use case**: Track unacknowledged messages to detect slow consumers.

**NRQL examples:**

View unacknowledged messages:

```sql
SELECT latest(rabbitmq.message.current) AS 'Unacked Messages'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.current'
  AND state = 'unacknowledged'
FACET rabbitmq.queue.name
```

**rabbitmq.message.current (all states)**

**Type**: Gauge  
**Unit**: Messages  
**Description**: Total number of messages in the queue across all states.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Overall queue depth monitoring.

**NRQL examples:**

View total messages per queue:

```sql
SELECT sum(rabbitmq.message.current) AS 'Total Messages'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.current'
FACET rabbitmq.queue.name
```

**rabbitmq.message.published**

**Type**: Counter  
**Unit**: Messages  
**Description**: Total number of messages published to the queue.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Monitor message ingestion rate.

**NRQL examples:**

View message publish rate:

```sql
SELECT rate(sum(rabbitmq.message.published), 1 minute) AS 'Publish Rate (msg/min)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.published'
FACET rabbitmq.queue.name
TIMESERIES
```

**rabbitmq.message.delivered**

**Type**: Counter  
**Unit**: Messages  
**Description**: Total number of messages delivered to consumers.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Track message delivery throughput.

**NRQL examples:**

View message delivery rate:

```sql
SELECT rate(sum(rabbitmq.message.delivered), 1 minute) AS 'Delivery Rate (msg/min)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.delivered'
FACET rabbitmq.queue.name
TIMESERIES
```

**rabbitmq.message.acknowledged**

**Type**: Counter  
**Unit**: Messages  
**Description**: Total number of messages acknowledged by consumers.

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Monitor message processing completion.

**NRQL examples:**

View acknowledgment rate:

```sql
SELECT rate(sum(rabbitmq.message.acknowledged), 1 minute) AS 'Ack Rate (msg/min)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.acknowledged'
FACET rabbitmq.queue.name
TIMESERIES
```

**rabbitmq.message.dropped**

**Type**: Counter  
**Unit**: Messages  
**Description**: Number of messages dropped (rejected or expired).

**Dimensions**:

-   `rabbitmq.queue.name`: Name of the queue

**Use case**: Identify message loss.

**NRQL examples:**

View dropped messages:

```sql
SELECT sum(rabbitmq.message.dropped) AS 'Dropped Messages'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.dropped'
FACET rabbitmq.queue.name
SINCE 1 hour ago
```

Track drop rate:

```sql
SELECT rate(sum(rabbitmq.message.dropped), 1 minute) AS 'Drop Rate (msg/min)'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.message.dropped'
FACET rabbitmq.queue.name
TIMESERIES
```

## Connection and lifecycle metrics [#connection-metrics]

Connection and lifecycle metrics track connection, channel, and queue lifecycle events.

**rabbitmq.node.connection_created_details.rate**

**Type**: Gauge  
**Unit**: Connections per second  
**Description**: Rate of new connections created per second.

**Use case**: Monitor connection establishment patterns.

**NRQL examples:**

View connection creation rate:

```sql
SELECT latest(rabbitmq.node.connection_created_details.rate) AS 'Connections Created/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.connection_created_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.connection_closed_details.rate**

**Type**: Gauge  
**Unit**: Connections per second  
**Description**: Rate of connections closed per second.

**Use case**: Monitor connection termination patterns.

**NRQL examples:**

View connection closure rate:

```sql
SELECT latest(rabbitmq.node.connection_closed_details.rate) AS 'Connections Closed/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.connection_closed_details.rate'
FACET host.name
TIMESERIES
```

Compare connection creation vs closure:

```sql
SELECT 
  latest(rabbitmq.node.connection_created_details.rate) AS 'Created',
  latest(rabbitmq.node.connection_closed_details.rate) AS 'Closed'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
FACET host.name
TIMESERIES
```

**rabbitmq.node.channel_created_details.rate**

**Type**: Gauge  
**Unit**: Channels per second  
**Description**: Rate of channels created per second.

**Use case**: Monitor channel lifecycle.

**NRQL examples:**

View channel creation rate:

```sql
SELECT latest(rabbitmq.node.channel_created_details.rate) AS 'Channels Created/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.channel_created_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.channel_closed_details.rate**

**Type**: Gauge  
**Unit**: Channels per second  
**Description**: Rate of channels closed per second.

**Use case**: Monitor channel termination.

**NRQL examples:**

View channel closure rate:

```sql
SELECT latest(rabbitmq.node.channel_closed_details.rate) AS 'Channels Closed/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.channel_closed_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.queue_declared_details.rate**

**Type**: Gauge  
**Unit**: Queues per second  
**Description**: Rate of queues declared per second.

**Use case**: Monitor queue declaration activity.

**NRQL examples:**

View queue declaration rate:

```sql
SELECT latest(rabbitmq.node.queue_declared_details.rate) AS 'Queues Declared/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.queue_declared_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.queue_created_details.rate**

**Type**: Gauge  
**Unit**: Queues per second  
**Description**: Rate of queues created per second.

**Use case**: Monitor queue creation.

**NRQL examples:**

View queue creation rate:

```sql
SELECT latest(rabbitmq.node.queue_created_details.rate) AS 'Queues Created/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.queue_created_details.rate'
FACET host.name
TIMESERIES
```

**rabbitmq.node.queue_deleted_details.rate**

**Type**: Gauge  
**Unit**: Queues per second  
**Description**: Rate of queues deleted per second.

**Use case**: Monitor queue deletion.

**NRQL examples:**

View queue deletion rate:

```sql
SELECT latest(rabbitmq.node.queue_deleted_details.rate) AS 'Queues Deleted/sec'
FROM Metric
WHERE instrumentation.provider = 'opentelemetry'
  AND metricName = 'rabbitmq.node.queue_deleted_details.rate'
FACET host.name
TIMESERIES
```

## What's next? [#whats-next]

Now that you have the complete RabbitMQ metrics reference, put this knowledge to use:

**Learn more:**

-   [Overview](https://docs.newrelic.com/docs/opentelemetry/integrations/rabbitmq/overview) - Learn about RabbitMQ integration architecture and deployment options
-   [Find and query your data](https://docs.newrelic.com/docs/opentelemetry/integrations/rabbitmq/find-and-query-data) - Navigate New Relic UI and write NRQL queries

**Take action:**

-   [Configure alerts](https://docs.newrelic.com/docs/alerts-applied-intelligence/new-relic-alerts/get-started/introduction-alerts) - Set up alerts for queue depths, memory usage, and disk space
-   [Build dashboards](https://docs.newrelic.com/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards) - Create custom dashboards to visualize your RabbitMQ metrics