--- title: RabbitMQ description: Track queue size, consumer count, unacknowledged messages, and more. breadcrumbs: Docs > Integrations > RabbitMQ --- # RabbitMQ Supported OS Integration version8.6.0 ## Overview{% #overview %} This check monitors [RabbitMQ](https://www.rabbitmq.com) through the Datadog Agent. It allows you to: - Track queue-based stats: queue size, consumer count, unacknowledged messages, redelivered messages, and more. - Track node-based stats: waiting processes, used sockets, used file descriptors, and more. - Monitor vhosts for aliveness and number of connections. Consider [Data Streams Monitoring](https://docs.datadoghq.com/data_streams/) to enhance your RabbitMQ integration. This solution enables pipeline visualization and lag tracking, helping you identify and resolve bottlenecks. **Minimum Agent version:** 6.0.0 ## Setup{% #setup %} ### Installation{% #installation %} The RabbitMQ check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server. ### Configuration{% #configuration %} RabbitMQ exposes metrics in two ways: the [RabbitMQ Management Plugin](https://www.rabbitmq.com/management.html) and the [RabbitMQ Prometheus Plugin](https://www.rabbitmq.com/prometheus.html). The Datadog integration supports both versions. Follow the configuration instruction in this file that pertain to the version you intend to use. The Datadog integration also comes with an out-of-the-box dashboard and monitors for each version, as labeled by the Dashboard and Monitor titles. #### Prepare RabbitMQ{% #prepare-rabbitmq %} ##### [RabbitMQ Prometheus Plugin](https://www.rabbitmq.com/prometheus.html).{% #rabbitmq-prometheus-plugin %} *Starting with RabbitMQ v3.8, the [RabbitMQ Prometheus Plugin](https://www.rabbitmq.com/prometheus.html) is enabled by default.* *The Prometheus plugin version of RabbitMQ requires Python 3 support by the Datadog Agent, and so can only be supported by Agent v6 or later. Please ensure your agent is updated before configuring the Prometheus plugin version of the integration.* Configure the `prometheus_plugin` section in your instance configuration. When using the `prometheus_plugin` option, settings related to the Management Plugin are ignored. ```yaml instances: - prometheus_plugin: url: http://:15692 ``` This enables scraping of the [`/metrics` endpoint](https://www.rabbitmq.com/prometheus.html#default-endpoint) on one RabbitMQ node. Datadog can also collect data from the [`/metrics/detailed` endpoint](https://www.rabbitmq.com/prometheus.html#detailed-endpoint). The metrics collected will depend on which families are included. ```yaml instances: - prometheus_plugin: url: http://:15692 unaggregated_endpoint: detailed?family=queue_coarse_metrics&family=queue_consumer_count&family=channel_exchange_metrics&family=channel_queue_exchange_metrics&family=node_coarse_metrics ``` This configuration collects metrics for each queue, exchange, and node. See the [`/metrics/detailed` API documentation](https://www.rabbitmq.com/prometheus.html#detailed-endpoint) for more information on the metrics provided by each family. ##### [RabbitMQ Management Plugin](https://www.rabbitmq.com/management.html).{% #rabbitmq-management-plugin %} Enable the plugin. The Agent user then needs at least the `monitoring` tag and these required permissions: | Permission | Command | | ---------- | ------------------ | | **conf** | `^aliveness-test$` | | **write** | `^amq\.default$` | | **read** | `.*` | Create an Agent user for your default vhost with the following commands: ```text rabbitmqctl add_user datadog rabbitmqctl set_permissions -p / datadog "^aliveness-test$" "^amq\.default$" ".*" rabbitmqctl set_user_tags datadog monitoring ``` Here, `/` refers to the default host. Set this to your specified virtual host name. See the [RabbitMQ documentation](https://www.rabbitmq.com/rabbitmqctl.8.html#set_permissions) for more information. {% tab title="Host" %} #### Host{% #host %} To configure this check for an Agent running on a host: ##### Metric collection{% #metric-collection %} 1. Edit the `rabbitmq.d/conf.yaml` file, in the `conf.d/` folder at the root of your [Agent's configuration directory](https://docs.datadoghq.com/agent/guide/agent-configuration-files/#agent-configuration-directory) to start collecting your RabbitMQ metrics. See the [sample rabbitmq.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/rabbitmq/datadog_checks/rabbitmq/data/conf.yaml.example) for all available configuration options. **Note**: The Agent checks all queues, vhosts, and nodes by default, but you can provide lists or regexes to limit this. See the [rabbitmq.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/rabbitmq/datadog_checks/rabbitmq/data/conf.yaml.example) for examples. 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). ##### Log collection{% #log-collection %} *Available for Agent versions >6.0* 1. To modify the default log file location either set the `RABBITMQ_LOGS` environment variable or add the following to your RabbitMQ configuration file (`/etc/rabbitmq/rabbitmq.conf`): ```gdscript3 log.dir = /var/log/rabbit log.file = rabbit.log ``` 1. Collecting logs is disabled by default in the Datadog Agent, enable it in your `datadog.yaml` file: ```yaml logs_enabled: true ``` 1. Edit the `logs` section of your `rabbitmq.d/conf.yaml` file to start collecting your RabbitMQ logs: ```yaml logs: - type: file path: /var/log/rabbit/*.log source: rabbitmq service: myservice log_processing_rules: - type: multi_line name: logs_starts_with_equal_sign pattern: "=" ``` 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). {% /tab %} {% tab title="Containerized" %} #### Containerized{% #containerized %} You can take advantage of Datadog's [Docker container Autodiscovery](https://docs.datadoghq.com/containers/docker/integrations/?tab=dockeradv2), see the `auto_conf.yaml` example configuration for RabbitMQ-specific settings. For container environments such as Kubernetes, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations/) for guidance on applying the parameters below. ##### Metric collection{% #metric-collection %} | Parameter | Value | | -------------------- | --------------------------------------------------------- | | `` | `rabbitmq` | | `` | blank or `{}` | | `` | `{"prometheus_plugin": {"url": "http://%%host%%:15692"}}` | ##### Log collection{% #log-collection %} *Available for Agent v6.0 or later* Collecting logs is disabled by default in the Datadog Agent. To enable it, see [Kubernetes Log Collection](https://docs.datadoghq.com/agent/kubernetes/log/). | Parameter | Value | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | | `` | `{"source": "rabbitmq", "service": "rabbitmq", "log_processing_rules": [{"type":"multi_line","name":"logs_starts_with_equal_sign", "pattern": "="}]}` | {% /tab %} ### Validation{% #validation %} [Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) and look for `rabbitmq` under the Checks section. ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **rabbitmq.alarms.file\_descriptor\_limit**(gauge) | [OpenMetrics] is 1 if file descriptor limit alarm is in effect | | **rabbitmq.alarms.free\_disk\_space.watermark**(gauge) | [OpenMetrics] is 1 if free disk space watermark alarm is in effect | | **rabbitmq.alarms.memory\_used\_watermark**(gauge) | [OpenMetrics] is 1 if VM memory watermark alarm is in effect | | **rabbitmq.auth\_attempts.count**(count) | [OpenMetrics] Total number of authentication attempts | | **rabbitmq.auth\_attempts.failed.count**(count) | [OpenMetrics] Total number of failed authentication attempts | | **rabbitmq.auth\_attempts.succeeded.count**(count) | [OpenMetrics] Total number of successful authentication attempts | | **rabbitmq.build\_info**(gauge) | [OpenMetrics] RabbitMQ & Erlang/OTP version info | | **rabbitmq.channel.acks\_uncommitted**(gauge) | [OpenMetrics] Message acknowledgements in a transaction not yet committed | | **rabbitmq.channel.consumers**(gauge) | [OpenMetrics] Consumers on a channel | | **rabbitmq.channel.get.ack.count**(count) | [OpenMetrics] Total number of messages fetched with basic.get in manual acknowledgement mode | | **rabbitmq.channel.get.count**(count) | [OpenMetrics] Total number of messages fetched with basic.get in automatic acknowledgement mode*Shown as message* | | **rabbitmq.channel.get.empty.count**(count) | [OpenMetrics] Total number of times basic.get operations fetched no message | | **rabbitmq.channel.messages.acked.count**(count) | [OpenMetrics] Total number of messages acknowledged by consumers*Shown as message* | | **rabbitmq.channel.messages.confirmed.count**(count) | [OpenMetrics] Total number of messages published into an exchange and confirmed on the channel*Shown as message* | | **rabbitmq.channel.messages.delivered.ack.count**(count) | [OpenMetrics] Total number of messages delivered to consumers in manual acknowledgement mode*Shown as message* | | **rabbitmq.channel.messages.delivered.count**(count) | [OpenMetrics] Total number of messages delivered to consumers in automatic acknowledgement mode*Shown as message* | | **rabbitmq.channel.messages.published.count**(count) | [OpenMetrics] Total number of messages published into an exchange on a channel*Shown as message* | | **rabbitmq.channel.messages.redelivered.count**(count) | [OpenMetrics] Total number of messages redelivered to consumers*Shown as message* | | **rabbitmq.channel.messages.unacked**(gauge) | [OpenMetrics] Delivered but not yet acknowledged messages*Shown as message* | | **rabbitmq.channel.messages.uncommitted**(gauge) | [OpenMetrics] Messages received in a transaction but not yet committed*Shown as message* | | **rabbitmq.channel.messages.unconfirmed**(gauge) | [OpenMetrics] Published but not yet confirmed messages*Shown as message* | | **rabbitmq.channel.messages.unroutable.dropped.count**(count) | [OpenMetrics] Total number of messages published as non-mandatory into an exchange and dropped as unroutable*Shown as message* | | **rabbitmq.channel.messages.unroutable.returned.count**(count) | [OpenMetrics] Total number of messages published as mandatory into an exchange and returned to the publisher as unroutable*Shown as message* | | **rabbitmq.channel.prefetch**(gauge) | [OpenMetrics] Total limit of unacknowledged messages for all consumers on a channel*Shown as message* | | **rabbitmq.channel.process\_reductions.count**(count) | [OpenMetrics] Total number of channel process reductions | | **rabbitmq.channels**(gauge) | [OpenMetrics] Channels currently open | | **rabbitmq.channels.closed.count**(count) | [OpenMetrics] Total number of channels closed | | **rabbitmq.channels.opened.count**(count) | [OpenMetrics] Total number of channels opened | | **rabbitmq.cluster.exchange\_bindings**(gauge) | [OpenMetrics] Number of bindings for an exchange. This value is cluster-wide. | | **rabbitmq.cluster.exchange\_name**(gauge) | [OpenMetrics] Enumerates exchanges without any additional info. This value is cluster-wide. A cheaper alternative to `exchange_bindings` | | **rabbitmq.cluster.vhost\_status**(gauge) | [OpenMetrics] Whether a given vhost is running | | **rabbitmq.connection.channels**(gauge) | [OpenMetrics] Channels on a connection | | **rabbitmq.connection.incoming\_bytes.count**(count) | [OpenMetrics] Total number of bytes received on a connection*Shown as byte* | | **rabbitmq.connection.incoming\_packets.count**(count) | [OpenMetrics] Total number of packets received on a connection*Shown as packet* | | **rabbitmq.connection.outgoing\_bytes.count**(count) | [OpenMetrics] Total number of bytes sent on a connection*Shown as byte* | | **rabbitmq.connection.outgoing\_packets.count**(count) | [OpenMetrics] Total number of packets sent on a connection*Shown as packet* | | **rabbitmq.connection.pending\_packets**(gauge) | [OpenMetrics] Number of packets waiting to be sent on a connection*Shown as packet* | | **rabbitmq.connection.process\_reductions.count**(count) | [OpenMetrics] Total number of connection process reductions | | **rabbitmq.connections**(gauge) | [OpenMetrics, Management CLI] Number of current connections to a given rabbitmq vhost, tagged 'rabbitmq_vhost:' Connections currently open*Shown as connection* | | **rabbitmq.connections.closed.count**(count) | [OpenMetrics] Total number of connections closed or terminated | | **rabbitmq.connections.opened.count**(count) | [OpenMetrics] Total number of connections opened | | **rabbitmq.connections.state**(gauge) | Number of connections in the specified connection state*Shown as connection* | | **rabbitmq.consumer\_prefetch**(gauge) | [OpenMetrics] Limit of unacknowledged messages for each consumer | | **rabbitmq.consumers**(gauge) | [OpenMetrics] Consumers currently connected | | **rabbitmq.disk\_space.available\_bytes**(gauge) | [OpenMetrics] Disk space available in bytes*Shown as byte* | | **rabbitmq.disk\_space.available\_limit\_bytes**(gauge) | [OpenMetrics] Free disk space low watermark in bytes*Shown as byte* | | **rabbitmq.erlang.gc.reclaimed\_bytes.count**(count) | [OpenMetrics] Total number of bytes of memory reclaimed by Erlang garbage collector*Shown as byte* | | **rabbitmq.erlang.gc.runs.count**(count) | [OpenMetrics] Total number of Erlang garbage collector runs | | **rabbitmq.erlang.mnesia.committed\_transactions.count**(count) | [OpenMetrics] Number of committed transactions.*Shown as transaction* | | **rabbitmq.erlang.mnesia.failed\_transactions.count**(count) | [OpenMetrics] Number of failed (i.e. aborted) transactions.*Shown as transaction* | | **rabbitmq.erlang.mnesia.held\_locks**(gauge) | [OpenMetrics] Number of held locks. | | **rabbitmq.erlang.mnesia.lock\_queue**(gauge) | [OpenMetrics] Number of transactions waiting for a lock.*Shown as transaction* | | **rabbitmq.erlang.mnesia.logged\_transactions.count**(count) | [OpenMetrics] Number of transactions logged.*Shown as transaction* | | **rabbitmq.erlang.mnesia.memory\_usage\_bytes**(gauge) | [OpenMetrics] Total number of bytes allocated by all mnesia tables*Shown as byte* | | **rabbitmq.erlang.mnesia.restarted\_transactions.count**(count) | [OpenMetrics] Total number of transaction restarts.*Shown as transaction* | | **rabbitmq.erlang.mnesia.tablewise\_memory\_usage\_bytes**(gauge) | [OpenMetrics] Number of bytes allocated per mnesia table*Shown as byte* | | **rabbitmq.erlang.mnesia.tablewise\_size**(gauge) | [OpenMetrics] Number of rows present per table | | **rabbitmq.erlang.mnesia.transaction\_coordinators**(gauge) | [OpenMetrics] Number of coordinator transactions.*Shown as transaction* | | **rabbitmq.erlang.mnesia.transaction\_participants**(gauge) | [OpenMetrics] Number of participant transactions.*Shown as transaction* | | **rabbitmq.erlang.net.ticktime\_seconds**(gauge) | [OpenMetrics] Inter-node heartbeat interval*Shown as second* | | **rabbitmq.erlang.processes\_limit**(gauge) | [OpenMetrics] Erlang processes limit*Shown as process* | | **rabbitmq.erlang.processes\_used**(gauge) | [OpenMetrics] Erlang processes used*Shown as process* | | **rabbitmq.erlang.scheduler.context\_switches.count**(count) | [OpenMetrics] Total number of Erlang scheduler context switches | | **rabbitmq.erlang.scheduler.run\_queue**(gauge) | [OpenMetrics] Erlang scheduler run queue | | **rabbitmq.erlang.uptime\_seconds**(gauge) | [OpenMetrics] Node uptime*Shown as second* | | **rabbitmq.erlang.vm.allocators**(gauge) | [OpenMetrics] Allocated (carriers_size) and used (blocks_size) memory for the different allocators in the VM. See erts_alloc(3). | | **rabbitmq.erlang.vm.atom\_count**(gauge) | [OpenMetrics] The number of atom currently existing at the local node. | | **rabbitmq.erlang.vm.atom\_limit**(gauge) | [OpenMetrics] The maximum number of simultaneously existing atom at the local node. | | **rabbitmq.erlang.vm.dirty\_cpu\_schedulers**(gauge) | [OpenMetrics] The number of scheduler dirty CPU scheduler threads used by the emulator.*Shown as thread* | | **rabbitmq.erlang.vm.dirty\_cpu\_schedulers\_online**(gauge) | [OpenMetrics] The number of dirty CPU scheduler threads online.*Shown as thread* | | **rabbitmq.erlang.vm.dirty\_io\_schedulers**(gauge) | [OpenMetrics] The number of scheduler dirty I/O scheduler threads used by the emulator.*Shown as thread* | | **rabbitmq.erlang.vm.dist.node\_queue\_size\_bytes**(gauge) | [OpenMetrics] The number of bytes in the output distribution queue. This queue sits between the Erlang code and the port driver.*Shown as byte* | | **rabbitmq.erlang.vm.dist.node\_state**(gauge) | [OpenMetrics] The current state of the distribution link. The state is represented as a numerical value where `pending=1',`up_pending=2' and `up=3'. | | **rabbitmq.erlang.vm.dist.proc.total\_heap\_size\_words**(gauge) | [OpenMetrics] The total size, in words, of all heap fragments of the process. This includes the process stack and any unreceived messages that are considered to be part of the heap. | | **rabbitmq.erlang.vm.dist.recv.avg\_bytes**(gauge) | [OpenMetrics] Average size of packets, in bytes, received by the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.recv.cnt**(gauge) | [OpenMetrics] Number of packets received by the socket. | | **rabbitmq.erlang.vm.dist.recv.dvi\_bytes**(gauge) | [OpenMetrics] Average packet size deviation, in bytes, received by the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.recv.max\_bytes**(gauge) | [OpenMetrics] Size of the largest packet, in bytes, received by the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.recv\_bytes**(gauge) | [OpenMetrics] Number of bytes received by the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.send.avg\_bytes**(gauge) | [OpenMetrics] Average size of packets, in bytes, sent from the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.send.cnt**(gauge) | [OpenMetrics] Number of packets sent from the socket. | | **rabbitmq.erlang.vm.dist.send.max\_bytes**(gauge) | [OpenMetrics] Size of the largest packet, in bytes, sent from the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.send.pend\_bytes**(gauge) | [OpenMetrics] Number of bytes waiting to be sent by the socket.*Shown as byte* | | **rabbitmq.erlang.vm.dist.send\_bytes**(gauge) | [OpenMetrics] Number of bytes sent from the socket.*Shown as byte* | | **rabbitmq.erlang.vm.ets\_limit**(gauge) | [OpenMetrics] The maximum number of ETS tables allowed. | | **rabbitmq.erlang.vm.logical\_processors**(gauge) | [OpenMetrics] The detected number of logical processors configured in the system. | | **rabbitmq.erlang.vm.logical\_processors.available**(gauge) | [OpenMetrics] The detected number of logical processors available to the Erlang runtime system. | | **rabbitmq.erlang.vm.logical\_processors.online**(gauge) | [OpenMetrics] The detected number of logical processors online on the system. | | **rabbitmq.erlang.vm.memory.atom\_bytes\_total**(gauge) | [OpenMetrics] The total amount of memory currently allocated for atoms. This memory is part of the memory presented as system memory.*Shown as byte* | | **rabbitmq.erlang.vm.memory.bytes\_total**(gauge) | [OpenMetrics] The total amount of memory currently allocated. This is the same as the sum of the memory size for processes and system.*Shown as byte* | | **rabbitmq.erlang.vm.memory.dets\_tables**(gauge) | [OpenMetrics] Erlang VM DETS Tables count. | | **rabbitmq.erlang.vm.memory.ets\_tables**(gauge) | [OpenMetrics] Erlang VM ETS Tables count. | | **rabbitmq.erlang.vm.memory.processes\_bytes\_total**(gauge) | [OpenMetrics] The total amount of memory currently allocated for the Erlang processes.*Shown as byte* | | **rabbitmq.erlang.vm.memory.system\_bytes\_total**(gauge) | [OpenMetrics] The total amount of memory currently allocated for the emulator that is not directly related to any Erlang process. Memory presented as processes is not included in this memory.*Shown as byte* | | **rabbitmq.erlang.vm.msacc.alloc\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent managing memory. Without extra states this time is spread out over all other states.*Shown as second* | | **rabbitmq.erlang.vm.msacc.aux\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent handling auxiliary jobs.*Shown as second* | | **rabbitmq.erlang.vm.msacc.bif\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent in BIFs. Without extra states this time is part of the 'emulator' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.busy\_wait\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent busy waiting. Without extra states this time is part of the 'other' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.check\_io\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent checking for new I/O events.*Shown as second* | | **rabbitmq.erlang.vm.msacc.emulator\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent executing Erlang processes.*Shown as second* | | **rabbitmq.erlang.vm.msacc.ets\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent executing ETS BIFs. Without extra states this time is part of the 'emulator' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.gc\_full\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent doing fullsweep garbage collection. Without extra states this time is part of the 'gc' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.gc\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent doing garbage collection. When extra states are enabled this is the time spent doing non-fullsweep garbage collections.*Shown as second* | | **rabbitmq.erlang.vm.msacc.nif\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent in NIFs. Without extra states this time is part of the 'emulator' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.other\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent doing unaccounted things.*Shown as second* | | **rabbitmq.erlang.vm.msacc.port\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent executing ports.*Shown as second* | | **rabbitmq.erlang.vm.msacc.send\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent sending messages (processes only). Without extra states this time is part of the 'emulator' state.*Shown as second* | | **rabbitmq.erlang.vm.msacc.sleep\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent sleeping.*Shown as second* | | **rabbitmq.erlang.vm.msacc.timers\_seconds.count**(count) | [OpenMetrics] Total time in seconds spent managing timers. Without extra states this time is part of the 'other' state.*Shown as second* | | **rabbitmq.erlang.vm.port\_count**(gauge) | [OpenMetrics] The number of ports currently existing at the local node. | | **rabbitmq.erlang.vm.port\_limit**(gauge) | [OpenMetrics] The maximum number of simultaneously existing ports at the local node. | | **rabbitmq.erlang.vm.process\_count**(gauge) | [OpenMetrics] The number of processes currently existing at the local node.*Shown as process* | | **rabbitmq.erlang.vm.process\_limit**(gauge) | [OpenMetrics] The maximum number of simultaneously existing processes at the local node.*Shown as process* | | **rabbitmq.erlang.vm.schedulers**(gauge) | [OpenMetrics] The number of scheduler threads used by the emulator. | | **rabbitmq.erlang.vm.schedulers\_online**(gauge) | [OpenMetrics] The number of schedulers online. | | **rabbitmq.erlang.vm.smp\_support**(gauge) | [OpenMetrics] 1 if the emulator has been compiled with SMP support, otherwise 0. | | **rabbitmq.erlang.vm.statistics.bytes\_output.count**(count) | [OpenMetrics] Total number of bytes output to ports.*Shown as byte* | | **rabbitmq.erlang.vm.statistics.bytes\_received.count**(count) | [OpenMetrics] Total number of bytes received through ports.*Shown as byte* | | **rabbitmq.erlang.vm.statistics.context\_switches.count**(count) | [OpenMetrics] Total number of context switches since the system started. | | **rabbitmq.erlang.vm.statistics.dirty\_cpu\_run\_queue\_length**(gauge) | [OpenMetrics] Length of the dirty CPU run-queue. | | **rabbitmq.erlang.vm.statistics.dirty\_io\_run\_queue\_length**(gauge) | [OpenMetrics] Length of the dirty IO run-queue. | | **rabbitmq.erlang.vm.statistics.garbage\_collection.bytes\_reclaimed.count**(count) | [OpenMetrics] Garbage collection: bytes reclaimed.*Shown as byte* | | **rabbitmq.erlang.vm.statistics.garbage\_collection.number\_of\_gcs.count**(count) | [OpenMetrics] Garbage collection: number of GCs. | | **rabbitmq.erlang.vm.statistics.garbage\_collection.words\_reclaimed.count**(count) | [OpenMetrics] Garbage collection: words reclaimed. | | **rabbitmq.erlang.vm.statistics.reductions.count**(count) | [OpenMetrics] Total reductions. | | **rabbitmq.erlang.vm.statistics.run\_queues\_length**(gauge) | [OpenMetrics] Length of normal run-queues. | | **rabbitmq.erlang.vm.statistics.runtime\_milliseconds.count**(count) | [OpenMetrics] The sum of the runtime for all threads in the Erlang runtime system. Can be greater than wall clock time.*Shown as millisecond* | | **rabbitmq.erlang.vm.statistics.wallclock\_time\_milliseconds.count**(count) | [OpenMetrics] Information about wall clock. Same as erlang_vm_statistics_runtime_milliseconds except that real time is measured.*Shown as millisecond* | | **rabbitmq.erlang.vm.thread\_pool\_size**(gauge) | [OpenMetrics] The number of async threads in the async thread pool used for asynchronous driver calls. | | **rabbitmq.erlang.vm.threads**(gauge) | [OpenMetrics] 1 if the emulator has been compiled with thread support, otherwise 0. | | **rabbitmq.erlang.vm.time\_correction**(gauge) | [OpenMetrics] 1 if time correction is enabled, otherwise 0. | | **rabbitmq.erlang.vm.wordsize\_bytes**(gauge) | [OpenMetrics] The size of Erlang term words in bytes.*Shown as byte* | | **rabbitmq.exchange.messages.ack.count**(gauge) | Number of messages in exchanges delivered to clients and acknowledged*Shown as message* | | **rabbitmq.exchange.messages.ack.rate**(gauge) | Rate of messages in exchanges delivered to clients and acknowledged per second*Shown as message* | | **rabbitmq.exchange.messages.confirm.count**(gauge) | Count of messages in exchanges confirmed*Shown as message* | | **rabbitmq.exchange.messages.confirm.rate**(gauge) | Rate of messages in exchanges confirmed per second*Shown as message* | | **rabbitmq.exchange.messages.deliver\_get.count**(gauge) | Sum of messages in exchanges delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get*Shown as message* | | **rabbitmq.exchange.messages.deliver\_get.rate**(gauge) | Rate per second of the sum of exchange messages delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get*Shown as message* | | **rabbitmq.exchange.messages.publish.count**(gauge) | Count of messages in exchanges published*Shown as message* | | **rabbitmq.exchange.messages.publish.rate**(gauge) | Rate of messages in exchanges published per second*Shown as message* | | **rabbitmq.exchange.messages.publish\_in.count**(gauge) | Count of messages published from channels into this exchange*Shown as message* | | **rabbitmq.exchange.messages.publish\_in.rate**(gauge) | Rate of messages published from channels into this exchange per sec*Shown as message* | | **rabbitmq.exchange.messages.publish\_out.count**(gauge) | Count of messages published from this exchange into queues*Shown as message* | | **rabbitmq.exchange.messages.publish\_out.rate**(gauge) | Rate of messages published from this exchange into queues per second*Shown as message* | | **rabbitmq.exchange.messages.redeliver.count**(gauge) | Count of subset of messages in exchanges in deliver_get which had the redelivered flag set*Shown as message* | | **rabbitmq.exchange.messages.redeliver.rate**(gauge) | Rate of subset of messages in exchanges in deliver_get which had the redelivered flag set per second*Shown as message* | | **rabbitmq.exchange.messages.return\_unroutable.count**(gauge) | Count of messages in exchanges returned to publisher as unroutable*Shown as message* | | **rabbitmq.exchange.messages.return\_unroutable.rate**(gauge) | Rate of messages in exchanges returned to publisher as unroutable per second*Shown as message* | | **rabbitmq.global.consumers**(gauge) | [OpenMetrics] Current number of consumers | | **rabbitmq.global.messages.acknowledged.count**(count) | [OpenMetrics] Total number of messages acknowledged by consumers*Shown as message* | | **rabbitmq.global.messages.confirmed.count**(count) | [OpenMetrics] Total number of messages confirmed to publishers*Shown as message* | | **rabbitmq.global.messages.dead\_lettered.confirmed.count**(count) | [OpenMetrics] Total number of messages dead-lettered and confirmed by target queues*Shown as message* | | **rabbitmq.global.messages.dead\_lettered.delivery\_limit.count**(count) | [OpenMetrics] Total number of messages dead-lettered due to delivery-limit exceeded*Shown as message* | | **rabbitmq.global.messages.dead\_lettered.expired.count**(count) | [OpenMetrics] Total number of messages dead-lettered due to message TTL exceeded*Shown as message* | | **rabbitmq.global.messages.dead\_lettered.maxlen.count**(count) | [OpenMetrics] Total number of messages dead-lettered due to overflow drop-head or reject-publish-dlx*Shown as message* | | **rabbitmq.global.messages.dead\_lettered.rejected.count**(count) | [OpenMetrics] Total number of messages dead-lettered due to basic.reject or basic.nack*Shown as message* | | **rabbitmq.global.messages.delivered.consume\_auto\_ack.count**(count) | [OpenMetrics] Total number of messages delivered to consumers using basic.consume with automatic acknowledgment*Shown as message* | | **rabbitmq.global.messages.delivered.consume\_manual\_ack.count**(count) | [OpenMetrics] Total number of messages delivered to consumers using basic.consume with manual acknowledgment*Shown as message* | | **rabbitmq.global.messages.delivered.count**(count) | [OpenMetrics] Total number of messages delivered to consumers*Shown as message* | | **rabbitmq.global.messages.delivered.get\_auto\_ack.count**(count) | [OpenMetrics] Total number of messages delivered to consumers using basic.get with automatic acknowledgment*Shown as message* | | **rabbitmq.global.messages.delivered.get\_manual\_ack.count**(count) | [OpenMetrics] Total number of messages delivered to consumers using basic.get with manual acknowledgment*Shown as message* | | **rabbitmq.global.messages.get\_empty.count**(count) | [OpenMetrics] Total number of times basic.get operations fetched no message | | **rabbitmq.global.messages.received.count**(count) | [OpenMetrics] Total number of messages received from publishers*Shown as message* | | **rabbitmq.global.messages.received\_confirm.count**(count) | [OpenMetrics] Total number of messages received from publishers expecting confirmations*Shown as message* | | **rabbitmq.global.messages.redelivered.count**(count) | [OpenMetrics] Total number of messages redelivered to consumers*Shown as message* | | **rabbitmq.global.messages.routed.count**(count) | [OpenMetrics] Total number of messages routed to queues or streams*Shown as message* | | **rabbitmq.global.messages.unroutable.dropped.count**(count) | [OpenMetrics] Total number of messages published as non-mandatory into an exchange and dropped as unroutable*Shown as message* | | **rabbitmq.global.messages.unroutable.returned.count**(count) | [OpenMetrics] Total number of messages published as mandatory into an exchange and returned to the publisher as unroutable*Shown as message* | | **rabbitmq.global.publishers**(gauge) | [OpenMetrics] Current number of publishers | | **rabbitmq.global.stream.error.access\_refused.count**(count) | [OpenMetrics] Total number of stream commands failed with access refused | | **rabbitmq.global.stream.error.authentication\_failure.count**(count) | [OpenMetrics] Total number of stream commands failed with authentication failure | | **rabbitmq.global.stream.error.frame\_too\_large.count**(count) | [OpenMetrics] Total number of stream commands failed with frame too large | | **rabbitmq.global.stream.error.internal\_error.count**(count) | [OpenMetrics] Total number of stream commands failed with internal error | | **rabbitmq.global.stream.error.precondition\_failed.count**(count) | [OpenMetrics] Total number of stream commands failed with precondition failed | | **rabbitmq.global.stream.error.publisher\_does\_not\_exist.count**(count) | [OpenMetrics] Total number of stream commands failed with publisher does not exist | | **rabbitmq.global.stream.error.sasl\_authentication\_failure\_loopback.count**(count) | [OpenMetrics] Total number of stream commands failed with sasl authentication failure loopback | | **rabbitmq.global.stream.error.sasl\_challenge.count**(count) | [OpenMetrics] Total number of stream commands failed with sasl challenge | | **rabbitmq.global.stream.error.sasl\_error.count**(count) | [OpenMetrics] Total number of stream commands failed with sasl error | | **rabbitmq.global.stream.error.sasl\_mechanism\_not\_supported.count**(count) | [OpenMetrics] Total number of stream commands failed with sasl mechanism not supported | | **rabbitmq.global.stream.error.stream\_already\_exists.count**(count) | [OpenMetrics] Total number of stream commands failed with stream already exists | | **rabbitmq.global.stream.error.stream\_does\_not\_exist.count**(count) | [OpenMetrics] Total number of stream commands rejected with stream does not exist error | | **rabbitmq.global.stream.error.stream\_not\_available.count**(count) | [OpenMetrics] Total number of stream commands failed with stream not available | | **rabbitmq.global.stream.error.subscription\_id\_already\_exists.count**(count) | [OpenMetrics] Total number of stream commands failed with subscription id already exists | | **rabbitmq.global.stream.error.subscription\_id\_does\_not\_exist.count**(count) | [OpenMetrics] Total number of stream commands failed with subscription id does not exist | | **rabbitmq.global.stream.error.unknown\_frame.count**(count) | [OpenMetrics] Total number of stream commands failed with unknown frame | | **rabbitmq.global.stream.error.vhost\_access\_failure.count**(count) | [OpenMetrics] Total number of stream commands failed with vhost access failure | | **rabbitmq.identity\_info**(gauge) | [OpenMetrics] RabbitMQ node & cluster identity info | | **rabbitmq.io.read\_bytes.count**(count) | [OpenMetrics] Total number of I/O bytes read*Shown as byte* | | **rabbitmq.io.read\_ops.count**(count) | [OpenMetrics] Total number of I/O read operations*Shown as operation* | | **rabbitmq.io.read\_time\_seconds.count**(count) | [OpenMetrics] Total I/O read time*Shown as second* | | **rabbitmq.io.reopen\_ops.count**(count) | [OpenMetrics] Total number of times files have been reopened | | **rabbitmq.io.seek\_ops.count**(count) | [OpenMetrics] Total number of I/O seek operations*Shown as operation* | | **rabbitmq.io.seek\_time\_seconds.count**(count) | [OpenMetrics] Total I/O seek time*Shown as second* | | **rabbitmq.io.sync\_ops.count**(count) | [OpenMetrics] Total number of I/O sync operations*Shown as operation* | | **rabbitmq.io.sync\_time\_seconds.count**(count) | [OpenMetrics] Total I/O sync time*Shown as second* | | **rabbitmq.io.write\_bytes.count**(count) | [OpenMetrics] Total number of I/O bytes written*Shown as byte* | | **rabbitmq.io.write\_ops.count**(count) | [OpenMetrics] Total number of I/O write operations*Shown as operation* | | **rabbitmq.io.write\_time\_seconds.count**(count) | [OpenMetrics] Total I/O write time*Shown as second* | | **rabbitmq.msg\_store.read.count**(count) | [OpenMetrics] Total number of Message Store read operations*Shown as operation* | | **rabbitmq.msg\_store.write.count**(count) | [OpenMetrics] Total number of Message Store write operations*Shown as operation* | | **rabbitmq.node.disk\_alarm**(gauge) | Does the node have disk alarm | | **rabbitmq.node.disk\_free**(gauge) | Current free disk space*Shown as byte* | | **rabbitmq.node.fd\_used**(gauge) | Used file descriptors | | **rabbitmq.node.mem\_alarm**(gauge) | Does the host has memory alarm | | **rabbitmq.node.mem\_limit**(gauge) | Memory usage high watermark in bytes*Shown as byte* | | **rabbitmq.node.mem\_used**(gauge) | Memory used in bytes*Shown as byte* | | **rabbitmq.node.partitions**(gauge) | Number of network partitions this node is seeing | | **rabbitmq.node.run\_queue**(gauge) | Average number of Erlang processes waiting to run*Shown as process* | | **rabbitmq.node.running**(gauge) | Is the node running or not | | **rabbitmq.node.sockets\_used**(gauge) | Number of file descriptors used as sockets | | **rabbitmq.overview.messages.ack.count**(gauge) | Number of messages delivered to clients and acknowledged*Shown as message* | | **rabbitmq.overview.messages.ack.rate**(gauge) | Rate of messages delivered to clients and acknowledged per second*Shown as message* | | **rabbitmq.overview.messages.confirm.count**(gauge) | Count of messages confirmed*Shown as message* | | **rabbitmq.overview.messages.confirm.rate**(gauge) | Rate of messages confirmed per second*Shown as message* | | **rabbitmq.overview.messages.deliver\_get.count**(gauge) | Sum of messages delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get*Shown as message* | | **rabbitmq.overview.messages.deliver\_get.rate**(gauge) | Rate per second of the sum of messages delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get*Shown as message* | | **rabbitmq.overview.messages.drop\_unroutable.count**(gauge) | Count of messages dropped as unroutable*Shown as message* | | **rabbitmq.overview.messages.drop\_unroutable.rate**(gauge) | Rate of messages dropped as unroutable per second*Shown as message* | | **rabbitmq.overview.messages.publish.count**(gauge) | Count of messages published*Shown as message* | | **rabbitmq.overview.messages.publish.rate**(gauge) | Rate of messages published per second*Shown as message* | | **rabbitmq.overview.messages.publish\_in.count**(gauge) | Count of messages published from channels into this overview*Shown as message* | | **rabbitmq.overview.messages.publish\_in.rate**(gauge) | Rate of messages published from channels into this overview per sec*Shown as message* | | **rabbitmq.overview.messages.publish\_out.count**(gauge) | Count of messages published from this overview into queues*Shown as message* | | **rabbitmq.overview.messages.publish\_out.rate**(gauge) | Rate of messages published from this overview into queues per second*Shown as message* | | **rabbitmq.overview.messages.redeliver.count**(gauge) | Count of subset of messages in deliver_get which had the redelivered flag set*Shown as message* | | **rabbitmq.overview.messages.redeliver.rate**(gauge) | Rate of subset of messages in deliver_get which had the redelivered flag set per second*Shown as message* | | **rabbitmq.overview.messages.return\_unroutable.count**(gauge) | Count of messages returned to publisher as unroutable*Shown as message* | | **rabbitmq.overview.messages.return\_unroutable.rate**(gauge) | Rate of messages returned to publisher as unroutable per second*Shown as message* | | **rabbitmq.overview.object\_totals.channels**(gauge) | Total number of channels*Shown as item* | | **rabbitmq.overview.object\_totals.connections**(gauge) | Total number of connections*Shown as connection* | | **rabbitmq.overview.object\_totals.consumers**(gauge) | Total number of consumers*Shown as item* | | **rabbitmq.overview.object\_totals.queues**(gauge) | Total number of queues*Shown as item* | | **rabbitmq.overview.queue\_totals.messages.count**(gauge) | Total number of messages (ready plus unacknowledged)*Shown as message* | | **rabbitmq.overview.queue\_totals.messages.rate**(gauge) | Rate of number of messages (ready plus unacknowledged)*Shown as message* | | **rabbitmq.overview.queue\_totals.messages\_ready.count**(gauge) | Number of messages ready for delivery*Shown as message* | | **rabbitmq.overview.queue\_totals.messages\_ready.rate**(gauge) | Rate of number of messages ready for delivery*Shown as message* | | **rabbitmq.overview.queue\_totals.messages\_unacknowledged.count**(gauge) | Number of unacknowledged messages*Shown as message* | | **rabbitmq.overview.queue\_totals.messages\_unacknowledged.rate**(gauge) | Rate of number of unacknowledged messages*Shown as message* | | **rabbitmq.process.max\_fds**(gauge) | [OpenMetrics] Open file descriptors limit | | **rabbitmq.process.max\_tcp\_sockets**(gauge) | [OpenMetrics] Open TCP sockets limit | | **rabbitmq.process.open\_fds**(gauge) | [OpenMetrics] Open file descriptors | | **rabbitmq.process.open\_tcp\_sockets**(gauge) | [OpenMetrics] Open TCP sockets | | **rabbitmq.process.resident\_memory\_bytes**(gauge) | [OpenMetrics] Memory used in bytes*Shown as byte* | | **rabbitmq.process\_start\_time\_seconds**(gauge) | [OpenMetrics] Start time of the process since unix epoch in seconds.*Shown as second* | | **rabbitmq.queue.active\_consumers**(gauge) | Number of active consumers, consumers that can immediately receive any messages sent to the queue | | **rabbitmq.queue.bindings.count**(gauge) | Number of bindings for a specific queue | | **rabbitmq.queue.consumer\_capacity**(gauge) | [OpenMetrics] Consumer capacity | | **rabbitmq.queue.consumer\_utilisation**(gauge) | The ratio of time that a queue's consumers can take new messages*Shown as fraction* | | **rabbitmq.queue.consumers**(gauge) | Number of consumers | | **rabbitmq.queue.disk\_reads.count**(count) | [OpenMetrics] Total number of times queue read messages from disk | | **rabbitmq.queue.disk\_writes.count**(count) | [OpenMetrics] Total number of times queue wrote messages to disk | | **rabbitmq.queue.get.ack.count**(count) | [OpenMetrics] Total number of messages fetched from a queue with basic.get in manual acknowledgement mode | | **rabbitmq.queue.get.count**(count) | [OpenMetrics] Total number of messages fetched from a queue with basic.get in automatic acknowledgement mode | | **rabbitmq.queue.get.empty.count**(count) | [OpenMetrics] Total number of times basic.get operations fetched no message on a queue | | **rabbitmq.queue.head\_message\_timestamp**(gauge) | [OpenMetrics, Management CLI] Timestamp of the head message of the queue Timestamp of the first message in the queue, if any*Shown as millisecond* | | **rabbitmq.queue.index.read\_ops.count**(count) | [OpenMetrics] Total number of Queue Index read operations*Shown as operation* | | **rabbitmq.queue.index.write\_ops.count**(count) | [OpenMetrics] Total number of Queue Index write operations*Shown as operation* | | **rabbitmq.queue.info**(gauge) | [OpenMetrics] A metric with a constant '1' value and labels that provide queue details including membership status and queue type | | **rabbitmq.queue.memory**(gauge) | Bytes of memory consumed by the Erlang process associated with the queue, including stack, heap, and internal structures*Shown as byte* | | **rabbitmq.queue.message\_bytes**(gauge) | Number of bytes of messages ready to be delivered to clients*Shown as message* | | **rabbitmq.queue.messages**(gauge) | [OpenMetrics, Management CLI] Count of the total messages in the queue, which is the sum of ready and unacknowledged messages (total queue depth)*Shown as message* | | **rabbitmq.queue.messages.ack.count**(gauge) | Number of messages in queues delivered to clients and acknowledged*Shown as message* | | **rabbitmq.queue.messages.ack.rate**(gauge) | Number per second of messages delivered to clients and acknowledged*Shown as message* | | **rabbitmq.queue.messages.acked.count**(count) | [OpenMetrics] Total number of messages acknowledged by consumers on a queue | | **rabbitmq.queue.messages.bytes**(gauge) | [OpenMetrics] Size in bytes of ready and unacknowledged messages*Shown as byte* | | **rabbitmq.queue.messages.deliver.count**(gauge) | Count of messages delivered in acknowledgement mode to consumers*Shown as message* | | **rabbitmq.queue.messages.deliver.rate**(gauge) | Rate of messages delivered in acknowledgement mode to consumers*Shown as message* | | **rabbitmq.queue.messages.deliver\_get.count**(gauge) | Sum of messages in queues delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get.*Shown as message* | | **rabbitmq.queue.messages.deliver\_get.rate**(gauge) | Rate per second of the sum of messages in queues delivered in acknowledgement mode to consumers, in no-acknowledgement mode to consumers, in acknowledgement mode in response to basic.get, and in no-acknowledgement mode in response to basic.get.*Shown as message* | | **rabbitmq.queue.messages.delivered.ack.count**(count) | [OpenMetrics] Total number of messages delivered from a queue to consumers in automatic acknowledgement mode | | **rabbitmq.queue.messages.delivered.count**(count) | [OpenMetrics] Total number of messages delivered from a queue to consumers in automatic acknowledgement mode | | **rabbitmq.queue.messages.paged\_out**(gauge) | [OpenMetrics] Messages paged out to disk | | **rabbitmq.queue.messages.paged\_out\_bytes**(gauge) | [OpenMetrics] Size in bytes of messages paged out to disk*Shown as byte* | | **rabbitmq.queue.messages.persistent**(gauge) | [OpenMetrics] Persistent messages*Shown as message* | | **rabbitmq.queue.messages.persistent\_bytes**(gauge) | [OpenMetrics] Size in bytes of persistent messages*Shown as byte* | | **rabbitmq.queue.messages.publish.count**(gauge) | Count of messages in queues published*Shown as message* | | **rabbitmq.queue.messages.publish.rate**(gauge) | Rate per second of messages published*Shown as message* | | **rabbitmq.queue.messages.published.count**(count) | [OpenMetrics] Total number of messages published to queues*Shown as message* | | **rabbitmq.queue.messages.ram**(gauge) | [OpenMetrics] Ready and unacknowledged messages stored in memory*Shown as message* | | **rabbitmq.queue.messages.ram\_bytes**(gauge) | [OpenMetrics] Size of ready and unacknowledged messages stored in memory*Shown as byte* | | **rabbitmq.queue.messages.rate**(gauge) | Count per second of the total messages in the queue*Shown as message* | | **rabbitmq.queue.messages.ready**(gauge) | [OpenMetrics] Messages ready to be delivered to consumers*Shown as message* | | **rabbitmq.queue.messages.ready\_bytes**(gauge) | [OpenMetrics] Size in bytes of ready messages*Shown as byte* | | **rabbitmq.queue.messages.ready\_ram**(gauge) | [OpenMetrics] Ready messages stored in memory*Shown as message* | | **rabbitmq.queue.messages.redeliver.count**(gauge) | Count of subset of messages in queues in deliver_get which had the redelivered flag set*Shown as message* | | **rabbitmq.queue.messages.redeliver.rate**(gauge) | Rate per second of subset of messages in deliver_get which had the redelivered flag set*Shown as message* | | **rabbitmq.queue.messages.redelivered.count**(count) | [OpenMetrics] Total number of messages redelivered from a queue to consumers | | **rabbitmq.queue.messages.unacked**(gauge) | [OpenMetrics] Messages delivered to consumers but not yet acknowledged*Shown as message* | | **rabbitmq.queue.messages.unacked\_bytes**(gauge) | [OpenMetrics] Size in bytes of all unacknowledged messages*Shown as byte* | | **rabbitmq.queue.messages.unacked\_ram**(gauge) | [OpenMetrics] Unacknowledged messages stored in memory*Shown as message* | | **rabbitmq.queue.messages\_ready**(gauge) | Number of messages ready to be delivered to clients*Shown as message* | | **rabbitmq.queue.messages\_ready.rate**(gauge) | Number per second of messages ready to be delivered to clients*Shown as message* | | **rabbitmq.queue.messages\_unacknowledged**(gauge) | Number of messages delivered to clients but not yet acknowledged*Shown as message* | | **rabbitmq.queue.messages\_unacknowledged.rate**(gauge) | Number per second of messages delivered to clients but not yet acknowledged*Shown as message* | | **rabbitmq.queue.process\_memory\_bytes**(gauge) | [OpenMetrics] Memory in bytes used by the Erlang queue process*Shown as byte* | | **rabbitmq.queue.process\_reductions.count**(count) | [OpenMetrics] Total number of queue process reductions | | **rabbitmq.queues**(gauge) | [OpenMetrics] Queues available | | **rabbitmq.queues.created.count**(count) | [OpenMetrics] Total number of queues created | | **rabbitmq.queues.declared.count**(count) | [OpenMetrics] Total number of queues declared | | **rabbitmq.queues.deleted.count**(count) | [OpenMetrics] Total number of queues deleted | | **rabbitmq.raft.entry\_commit\_latency\_seconds**(gauge) | [OpenMetrics] Time taken for a log entry to be committed*Shown as second* | | **rabbitmq.raft.log.commit\_index**(gauge) | [OpenMetrics] Raft log commit index | | **rabbitmq.raft.log.last\_applied\_index**(gauge) | [OpenMetrics] Raft log last applied index | | **rabbitmq.raft.log.last\_written\_index**(gauge) | [OpenMetrics] Raft log last written index | | **rabbitmq.raft.log.snapshot\_index**(gauge) | [OpenMetrics] Raft log snapshot index | | **rabbitmq.raft.term.count**(count) | [OpenMetrics] Current Raft term number | | **rabbitmq.resident\_memory\_limit\_bytes**(gauge) | [OpenMetrics] Memory high watermark in bytes*Shown as byte* | | **rabbitmq.schema.db.disk\_tx.count**(count) | [OpenMetrics] Total number of Schema DB disk transactions*Shown as transaction* | | **rabbitmq.schema.db.ram\_tx.count**(count) | [OpenMetrics] Total number of Schema DB memory transactions*Shown as transaction* | | **rabbitmq.stream.consumer\_max\_offset\_lag**(gauge) | [OpenMetrics] Highest consumer offset lag across all stream consumers | | **rabbitmq.stream.segments.count**(count) | [OpenMetrics] Total number of stream segment files | | **rabbitmq.telemetry.scrape.duration\_seconds.count**(count) | [OpenMetrics] Scrape duration*Shown as second* | | **rabbitmq.telemetry.scrape.duration\_seconds.sum**(count) | [OpenMetrics] Scrape duration*Shown as second* | | **rabbitmq.telemetry.scrape.encoded\_size\_bytes.count**(count) | [OpenMetrics] Scrape size, encoded*Shown as byte* | | **rabbitmq.telemetry.scrape.encoded\_size\_bytes.sum**(count) | [OpenMetrics] Scrape size, encoded*Shown as byte* | | **rabbitmq.telemetry.scrape.size\_bytes.count**(count) | [OpenMetrics] Scrape size, not encoded*Shown as byte* | | **rabbitmq.telemetry.scrape.size\_bytes.sum**(count) | [OpenMetrics] Scrape size, not encoded*Shown as byte* | ### Events{% #events %} ### Service Checks{% #service-checks %} **rabbitmq.aliveness** Only available with the RabbitMQ Management Plugin. Returns the status of a vhost based on the RabbitMQ [Aliveness API](https://github.com/rabbitmq/rabbitmq-management/blob/rabbitmq_v3_6_8/priv/www/api/index.html). The Aliveness API creates a test queue, then publishes and consumes a message from that queue. Returns `OK` if the status code from the API is 200 and `CRITICAL` otherwise. *Statuses: ok, critical* **rabbitmq.status** Only available with the RabbitMQ Management Plugin. Returns the status of the RabbitMQ server. Returns `OK` if the agent was able to contact the API and `CRITICAL` otherwise. *Statuses: ok, critical* **rabbitmq.openmetrics.health** Only available with the RabbitMQ Prometheus Plugin. Returns `CRITICAL` if the Agent is unable to connect to the OpenMetrics endpoint, otherwise returns `OK`. *Statuses: ok, critical* ## Troubleshooting{% #troubleshooting %} ### Migrating to Prometheus Plugin{% #migrating-to-prometheus-plugin %} The Prometheus Plugin exposes a different set of metrics from the Management Plugin. Here is what to be aware of as you migrate from the Management to the Prometheus Plugin. - Look up your metrics in [this table](https://docs.datadoghq.com/integrations/rabbitmq/?tab=host#metrics). If a metric's description contains an `[OpenMetrics]` tag, then it is available in the Prometheus Plugin. Metrics available only in the Management Plugin do not have any tags in their descriptions. - Any dashboards and monitors using Management Plugin metrics do not function. Switch to the dashboards and monitors marked as *OpenMetrics Version*. - The default configuration collects aggregated metrics. This means, for example, that there are no metrics tagged by queue. Configure the option `prometheus_plugin.unaggregated_endpoint` to get metrics without aggregation. - The `rabbitmq.status` service check is replaced by `rabbitmq.openmetrics.health`. The service check `rabbitmq.aliveness` has no equivalent in the Prometheus Plugin. The Prometheus Plugin changes some tags. The table below describes the changes to the more common tags. | Management | Prometheus | | ------------------- | ---------------------------------------- | | `queue_name` | `queue` | | `rabbitmq_vhost` | `vhost`, `exchange_vhost`, `queue_vhost` | | `rabbitmq_exchange` | `exchange` | For more information, see [Tagging RabbitMQ queues by tag family](https://docs.datadoghq.com/integrations/faq/tagging-rabbitmq-queues-by-tag-family/). Need help? Contact [Datadog support](https://docs.datadoghq.com/help/). ## Further Reading{% #further-reading %} - [Key metrics for RabbitMQ monitoring](https://www.datadoghq.com/blog/rabbitmq-monitoring) - [Collecting metrics using RabbitMQ monitoring tools](https://www.datadoghq.com/blog/rabbitmq-monitoring-tools) - [RabbitMQ monitoring with Datadog](https://www.datadoghq.com/blog/monitoring-rabbitmq-performance-with-datadog)