How to calculate RabbitMQ memory usage per queue?▼
Total queue memory is calculated as: M_total = M_payload + M_metadata + M_inflight + M_socket, where M_payload represents message bodies resident in RAM, M_metadata represents BEAM process index overhead (~32B for Classic Queue v2, ~140B for Classic Queue v1, ~384B for Quorum Queues), M_inflight = Consumers * basic.qos Prefetch * (Payload + Metadata), and M_socket allocates 64KB-256KB per TCP connection. For example, 50 consumers with prefetch set to 100 processing 4KB messages pin 50 * 100 * 4.12KB = 20.6 MB in unpageable in-flight RAM alone.
What is a good vm_memory_high_watermark benchmark for production RabbitMQ?▼
The recommended production benchmark for vm_memory_high_watermark is 0.40 to 0.45 (40% to 45% of total system RAM), reserving the remaining 55% to 60% for operating system page cache, socket buffers, and Erlang BEAM garbage collection compaction sweeps. Setting the watermark above 0.55 creates severe risk of Linux Out-Of-Memory (OOM) killer invocation, because Erlang's copying garbage collector can momentarily double a process's resident heap size during memory compaction before memory alarms can throttle incoming publishes.
How much memory does a Quorum Queue use compared to Classic Queue?▼
For active in-memory messages, Quorum queues require approximately 30% to 40% more memory per message than Classic Queue v2 due to Raft consensus tracking (term, index, and command metadata: ~384B vs ~32B per message). However, Quorum queues store log segments directly on disk and maintain an eviction cache window, completely eliminating the severe Erlang heap fragmentation and cluster-wide synchronization stalls that plague legacy mirrored Classic Queues (HA sync).
What happens when RabbitMQ hits vm_memory_high_watermark?▼
When total Erlang memory usage exceeds vm_memory_high_watermark, RabbitMQ immediately trips a cluster-wide memory alarm, stops reading from producer TCP sockets, and suspends basic.publish processing. Producers block on their local TCP socket write buffers without receiving an AMQP error, while consumers continue processing unblocked. Once resident memory drops below the watermark through message consumption and BEAM garbage collection, RabbitMQ clears the alarm and automatically resumes publisher socket polling.
How does consumer prefetch count (QoS) affect RabbitMQ RAM?▼
The basic.qos prefetch setting defines how many unacknowledged messages RabbitMQ pushes to a consumer before waiting for a basic.ack. Dispatched messages are pinned in Erlang process memory and cannot be paged to disk regardless of memory pressure. If 50 consumers have prefetch set to 1,000 handling 10KB messages, this allocates 50 * 1,000 * 10KB = 500 MB of unpageable in-flight RAM. Restricting prefetch to 50-100 maintains line-rate network saturation while keeping in-flight RAM below 50 MB.
How to calculate RabbitMQ queue backlog drain time?▼
Backlog drain time is calculated using the formula: Drain Time (seconds) = Backlog Message Count / (Total Consumer Drain Rate msg/s - Incoming Publish Rate msg/s). If 20 consumers acknowledge 150 msg/s each (3,000 msg/s aggregate) against an incoming publish rate of 1,000 msg/s, the net drain velocity is 2,000 msg/s. A backlog of 500,000 messages will drain in 500,000 / 2,000 = 250 seconds (4 minutes and 10 seconds). If consumer rate is less than or equal to publish rate, backlog drain time is infinite and indicates an expanding queue.
What is the difference between Classic Queue v1 and v2 memory overhead?▼
Classic Queue v1 (CQv1) stores queue indexes inside Erlang process dictionary structures, retaining 120B to 140B in RAM per message even after payload bodies page out to disk. In contrast, Classic Queue v2 (CQv2) stores messages and indexes in immutable 32MB disk segment files, reducing in-memory overhead for paged messages by over 75% down to approximately 32B per message. In a 10-million message backlog, CQv1 forces ~1.4 GB of resident Erlang heap index memory, while CQv2 requires only ~320 MB.
