Memory: guides, integrations and articles

Guides

Cassandra Operations Guides 5 pages

Open the Cassandra Operations Guides hub

Cassandra GC death spiral: long pauses, gossip flapping, and recovery

Operational guide to identifying, diagnosing, and recovering from Cassandra GC death spirals caused by heap pressure, gossip timeouts, and hint replay floods.

Cassandra GC pauses too long: diagnosing G1 stop-the-world pauses

Diagnose and resolve long G1 stop-the-world pauses in Cassandra before they trigger gossip failures and client timeouts.

Cassandra heap pressure: sizing the JVM heap and tuning G1GC

Size the JVM heap and tune G1GC for Cassandra 4.x and 5.x to avoid GC pauses, gossip flapping, and the death spiral.

Cassandra java.lang.OutOfMemoryError: Java heap space - causes and recovery

Diagnose and recover from Cassandra java.lang.OutOfMemoryError: Java heap space with heap sizing guidance, partition and batch analysis, and GC tuning.

Cassandra killed by the Linux OOM killer: off-heap memory and RSS

Diagnose and prevent Linux OOM kills on Cassandra nodes when off-heap RSS exceeds available RAM despite a healthy JVM heap.

ClickHouse Operations Guides 5 pages

Open the ClickHouse Operations Guides hub

ClickHouse killed by the OOM killer: RSS, max_server_memory_usage, and cgroup limits

Why ClickHouse is killed by the Linux OOM killer even when internal memory tracking looks healthy, and how to close the gap between RSS and MemoryTracking.

ClickHouse long-running queries: finding and killing the resource hog

Operational guide for identifying, diagnosing, and terminating ClickHouse queries that consume excessive resources or stall indefinitely.

ClickHouse Memory limit (for query) exceeded: per-query limits and GROUP BY/JOIN blowups

Troubleshoot ClickHouse error code 241 when per-query memory limits breach, including high-cardinality GROUP BY, unbounded DISTINCT, and Cartesian-product JOINs.

ClickHouse Memory limit (total) exceeded - server-wide memory pressure and fixes

Diagnose and fix the ClickHouse server-wide MEMORY_LIMIT_EXCEEDED error (code 241) when MemoryTracking hits max_server_memory_usage.

ClickHouse memory pressure death spiral: runaway queries, retries, and OOM

Diagnose and break the feedback loop where memory pressure, query kills, retries, and spill-to-disk compound into cascading failure.

CockroachDB Operations Guides 3 pages

Open the CockroachDB Operations Guides hub

CockroachDB error 53200: SQL memory budget exhausted and query rejection

Diagnose and fix CockroachDB error 53200 when per-node SQL memory budget exhaustion causes query rejection or disk spills.

CockroachDB memory pressure, GC thrashing, and Raft liveness failure

Diagnose and resolve the cycle where Go heap growth triggers long GC pauses, node liveness loss, and oscillating cluster availability.

CockroachDB out of memory: sys_rss, --cache, --max-sql-memory, and the OOM killer

Diagnose CockroachDB OOM kills by tracking sys_rss, CGo allocations, SQL memory budget, and the sizing relationship between --cache, --max-sql-memory, and container limits.

Docker Operations Guides 7 pages

Open the Docker Operations Guides hub

Docker container high memory usage: how to diagnose it

Diagnose elevated Docker container memory using cgroup memory.stat breakdown, distinguish reclaimable cache from anonymous memory, and fix runtime limit mismatches before OOM kills.

Docker container memory leak: how to find one and prove it

A runbook for operators to distinguish true container memory leaks from cache growth, prove the leak with cgroup and process signals, and fix or prevent OOM cascades.

Docker exit code 137: OOMKilled or SIGKILL?

Distinguish cgroup OOM kills from external SIGKILL when Docker containers exit with code 137. Use docker inspect, cgroup memory.events, and dmesg to find the real cause.

Docker JVM memory tuning: heap, off-heap, and the cgroup mismatch

Diagnose why Java containers are OOMKilled despite healthy heap usage, fix JVM cgroup detection failures, and size heap and off-heap limits correctly.

Docker memory limits: how to set them and what happens when they hit

How to configure Docker container memory limits, verify cgroup enforcement, and troubleshoot OOM kills, exit code 137, and cgroup v1 versus v2 differences.

Docker memory usage explained: anonymous, file, slab, and what counts

Understand how Docker reports container memory, what anonymous, file-backed, and slab memory mean, and which metrics actually predict OOM kills.

Docker OOMKilled: causes, detection, and prevention

How to detect, diagnose, and prevent Docker OOMKilled events: confirming the kill, distinguishing it from SIGKILL, JVM memory pitfalls, and right-sizing limits.

Elasticsearch Operations Guides 12 pages

Open the Elasticsearch Operations Guides hub

Elasticsearch cluster state too large: field count, index count, and per-node heap

Diagnose and fix an oversized Elasticsearch cluster state that burns heap on every node and overwhelms the master.

Elasticsearch coordinating node overload: aggregation merge, heap spikes, and 429s

Diagnose and fix Elasticsearch coordinating node overload caused by aggregation merges, heap spikes, and circuit breaker trips that return HTTP 429.

Elasticsearch fielddata circuit breaker tripped: text-field aggregations and the keyword fix

Diagnose and fix Elasticsearch fielddata circuit breaker trips caused by aggregating or sorting on analyzed text fields. Use keyword sub-fields and monitor the right signals.

Elasticsearch heap pressure death spiral: GC, node removal, and the cascade

How sustained heap pressure above 85% triggers old GC pauses, node removal, and cascading shard reallocation in Elasticsearch clusters, and how to break the cycle.

Elasticsearch JVM heap usage high: reading the sawtooth and the post-GC floor

Diagnose Elasticsearch JVM heap pressure by reading the post-GC floor instead of the sawtooth peak. Identify shard, fielddata, and aggregation drivers before they trigger GC death spirals.

Elasticsearch long GC pauses: old-generation stop-the-world and node drops

Diagnose and fix Elasticsearch old-generation GC pauses that trigger stop-the-world events, fault-detection timeouts, and cascading node removals.

Elasticsearch mapping explosion: dynamic mapping, cluster state bloat, and master pressure

Diagnose and fix Elasticsearch mapping explosion from dynamic mapping, including field limits, cluster state bloat, and master node pressure.

Elasticsearch master instability: frequent elections and metadata overload

Diagnose and fix Elasticsearch master node flapping caused by cluster state metadata overload, GC pauses, and election timeouts.

Elasticsearch monitoring checklist: the signals every production cluster needs

A production monitoring checklist for Elasticsearch organized by survival, operational, mature, and expert maturity levels.

Elasticsearch node left the cluster: fault detection, reallocation, and recovery

Diagnose and recover when an Elasticsearch node departs unexpectedly, including fault detection mechanics, delayed reallocation, and voting configuration cleanup.

Elasticsearch node OOM-killed: heap ceiling, page cache, and container limits

Diagnose and fix Elasticsearch nodes killed by the Linux OOM-killer due to heap, off-heap, page cache, and container memory limit pressure.

Fix Elasticsearch CircuitBreakingException Errors

Diagnose and resolve the Elasticsearch [parent] Data too large CircuitBreakingException. Covers real-memory tracking, heap consumers, task cancellation, and prevention.

Kafka Operations Guides 1 page

Open the Kafka Operations Guides hub

Kafka JVM heap and Full GC pauses: ISR drops, session timeouts, and right-sizing the heap

Diagnose and fix Kafka broker JVM heap pressure and Full GC pauses that trigger ISR shrinks, ZooKeeper session timeouts, and request latency spikes.

Kubernetes Operations Guides 5 pages

Open the Kubernetes Operations Guides hub

Kubernetes eviction cascade: when one node failure takes down the cluster

Diagnose and stop node-pressure eviction cascades caused by scheduler overplacement, cgroup v2 accounting changes, and missing hysteresis in Kubernetes clusters.

Kubernetes node MemoryPressure: detection, eviction order, and prevention

How kubelet detects node memory pressure, the QoS-based eviction order it follows, and how operators can diagnose and prevent pod eviction cascades.

Kubernetes pod CrashLoopBackOff: causes, diagnosis, and fixes

Practical troubleshooting guide for Kubernetes CrashLoopBackOff: identify root causes with kubectl and node signals, apply targeted fixes, and prevent recurrence.

Kubernetes pod Evicted: detection, root cause, and prevention

Detect, diagnose, and prevent Kubernetes pod eviction caused by node memory, disk, inode, and PID pressure.

Kubernetes pod OOMKilled: cgroup limits, evictions, and fixes

Diagnose and fix Kubernetes pod OOMKilled events by distinguishing container cgroup OOM from node-level kernel OOM and kubelet eviction.

Microsoft SQL Server Operations Guides 3 pages

Open the Microsoft SQL Server Operations Guides hub

SQL Server Error 701: there is insufficient system memory to run this query

Diagnose SQL Server Error 701 with checks for memory clerks, OS pressure, memory grants, and Resource Governor limits.

SQL Server PAGEIOLATCH waits: the buffer pool waiting on slow storage

Diagnose PAGEIOLATCH_SH and PAGEIOLATCH_EX by separating memory pressure from slow storage, using sys.dm_io_virtual_file_stats and wait stats deltas.

SQL Server RESOURCE_SEMAPHORE waits: queries stuck waiting for a memory grant

Diagnose and fix SQL Server RESOURCE_SEMAPHORE waits: what a memory grant queue means, how to find the hoarder, and when to page.

MongoDB Operations Guides 7 pages

Open the MongoDB Operations Guides hub

MongoDB Application Thread Evictions: How To Fix

Diagnose and fix WiredTiger cache eviction stalls when MongoDB application threads start evicting pages, causing sudden latency spikes.

MongoDB cache too small: sizing the WiredTiger cache for your working set

Size the WiredTiger cache to fit your working set. Covers default calculations, explicit overrides, container limits, and the signals that warn you before eviction stalls.

MongoDB connection storm spiral: reconnection floods after an election or deploy

Diagnose and break MongoDB connection storm spirals caused by elections, deploys, or network blips. Recognize RSS spikes, ticket contention, and totalCreated churn before they crash the node.

MongoDB exceeded memory limit for $group — aggregation spills and allowDiskUse

Fix MongoDB aggregation pipeline errors when $group or $sort hit the 100MB memory limit, diagnose disk spills, and restructure pipelines for production stability.

MongoDB OOM-killed by the kernel: RSS, cache sizing, and oom_score_adj

Diagnose and prevent Linux OOM kills targeting mongod by understanding RSS composition, WiredTiger cache sizing, and oom_score_adj protection.

MongoDB page faults high: working set exceeding memory after warmup

Diagnose and fix sustained high page fault rates in MongoDB when the working set exceeds both WiredTiger cache and OS page cache after warmup.

MongoDB RSS growing without cache growth: leaks, threads, and tcmalloc fragmentation

Diagnose why MongoDB resident memory grows while WiredTiger cache stays flat. Covers tcmalloc fragmentation, connection thread stacks, cursor leaks, and version-specific allocator changes.

MySQL Operations Guides 4 pages

Open the MySQL Operations Guides hub

MySQL InnoDB buffer pool hit ratio collapse: the cliff edge

Diagnose and fix InnoDB buffer pool hit ratio collapse when the working set exceeds memory, causing non-linear query degradation and cascading connection pressure.

MySQL innodb_buffer_pool_size tuning: 60-80% of RAM and when that breaks

Operational guide to sizing MySQL's InnoDB buffer pool, the 60-80% RAM heuristic, alignment constraints, and the container and memory gotchas that make it fail.

MySQL Innodb_buffer_pool_wait_free > 0: buffer pool memory pressure

Diagnose and fix InnoDB buffer pool memory pressure when Innodb_buffer_pool_wait_free climbs above zero.

MySQL OOM-killed: buffer pool, per-connection buffers, and the kernel killer

Diagnose and prevent Linux OOM killer evictions of MySQL by understanding buffer pool sizing, per-connection memory, and kernel interactions.

PostgreSQL Operations Guides 1 page

Open the PostgreSQL Operations Guides hub

PostgreSQL Out Of Memory: OOM Killer, shared_buffers & work_mem

Diagnose and prevent PostgreSQL OOM kills on Linux. Understand shared_buffers, work_mem per-operator allocation, and how to protect the postmaster from the OOM killer.

RabbitMQ Operations Guides 2 pages

Open the RabbitMQ Operations Guides hub

RabbitMQ memory resource limit alarm: publishers blocked across the whole cluster

What the RabbitMQ memory resource limit alarm means, why one node blocks publishers cluster-wide, and how to find and fix the cause without restarting the broker.

RabbitMQ memory usage climbing toward the watermark: mem_used vs mem_limit

How to read RabbitMQ's mem_used and mem_limit, why the ratio is the leading gauge before the memory alarm, and what to do when it climbs past 0.7.

Redis Operations Guides 11 pages

Open the Redis Operations Guides hub

Redis Can't save in background: fork: Cannot allocate memory - diagnosis and fix

Why Redis background saves fail with fork: Cannot allocate memory, how to diagnose vm.overcommit_memory and COW pressure, and how to fix it without restarting Redis.

Redis client output buffer overflow: slow consumers and client-output-buffer-limit

Diagnose and fix Redis client output buffer overflow from slow consumers, including omem analysis, client-output-buffer-limit tuning, and MONITOR detection.

Redis connected_clients climbing: connection leak detection

Diagnose and fix a sustained climb in Redis connected_clients when traffic is flat, including CLIENT LIST analysis, timeout configuration, and connection churn detection.

Redis eviction policy tuning: allkeys-lru vs volatile-ttl vs noeviction

How Redis maxmemory eviction policies work, when each policy is the right choice, and how to detect when the wrong policy is causing silent failures or OOM write rejections.

Redis fork/COW memory storm: why persistence doubles RSS and OOM-kills the box

Why Redis background saves trigger copy-on-write memory spikes that double RSS and OOM-kill containers, and how to diagnose, fix, and prevent them.

Redis latest_fork_usec too high: THP, NUMA, and fork latency

Diagnose and fix elevated Redis fork latency caused by Transparent Huge Pages, NUMA misconfiguration, and memory overcommit issues.

Redis maxmemory not set: why every production instance needs a memory limit

Running Redis without maxmemory is the most common production misconfiguration. Learn how to size it, pair it with an eviction policy, and avoid OOM kills.

Redis memory pressure spiral: eviction thrashing and how to break it

Diagnose and break the Redis memory pressure spiral where eviction, cache misses, and re-population writes feedback into each other.

Redis monitoring checklist: the signals every production instance needs

A production monitoring checklist for Redis organized by maturity level, from survival signals to expert-grade metrics that prevent silent degradation.

Redis OOM command not allowed when used memory > 'maxmemory' - causes and fixes

Troubleshoot Redis write rejections caused by maxmemory exhaustion under noeviction or volatile policies, diagnose silent failures, and fix the root cause without guessing.

Redis OOM-killed by the kernel: RSS, overcommit, and recovery

Why Redis dies to the kernel OOM killer even when used_memory looks healthy, how to diagnose RSS bloat from fragmentation and COW, and how to recover.

VMware vSphere Operations Guides 3 pages

Open the VMware vSphere Operations Guides hub

vSphere active vs consumed vs granted memory: why the percentage lies

Why a single vSphere host memory percentage is meaningless, and how to read active, consumed, granted, and the reclamation signals instead.

vSphere host swapping (SWCUR/SWW/s): hypervisor swap and the memory death spiral

Diagnose and resolve vSphere VMkernel swap activity (SWCUR, SWR/s, SWW/s) before the memory death spiral takes down every VM on the host.

vSphere memory ballooning (MCTLSZ): the host is reclaiming guest RAM

What non-zero MCTLSZ means, why ESXi reclaims guest memory, and how to stop sustained ballooning from degrading production VMs.

Apache ZooKeeper Operations Guides 1 page

Open the Apache ZooKeeper Operations Guides hub

ZooKeeper OutOfMemoryError: Java heap space - the OOM that kills the whole ensemble at once

Diagnose and stop the ZooKeeper Java heap space OOM that takes down an entire ensemble at once: data tree growth, GC death spiral, and heap sizing.

Academy

Linux Cgroups V2 Memory Throttling & OOM Fix

A deep dive into memory.max- memory.high- and PSI to understand and prevent container out-of-memory events

How To Find And Fix Memory Leaks in C or C++

A practical guide to C and C++ memory management- from manual detection to modern tools and best practices

What Is A Memory Leak In Java How To Detect And Fix Them

An essential guide for developers to diagnose and resolve OutOfMemoryError issues in their applications

Garbage Collection In Java What It Is and How It Works

Understanding the automatic memory management that powers the JVM

Nodejs Memory Leak How To Identify Debug And Avoid Them

A deep dive into Nodejs memory management- common leak causes- detection tools- and proactive strategies to keep your applications running smoothly.

Key Observability Metrics | Infrastructure & APM Monitoring

Understanding & Implementing Essential Infrastructure Metrics For Effective Monitoring

Kernel Same-page Merging (KSM) Monitoring

Learn about monitoring & troubleshooting Kernel Same-page Merging (KSM), what metrics and why, and how to monitor KSM with Netdata. Find out more.

Case Studies

Real-Time Insights for Reliable Web Hosting

Elevating Monitoring Simplicity and Efficiency

Blog

Understanding Huge Pages

Optimizing Memory Usage

Unlock the Secrets of Kernel Memory Usage

Diving Deep into Kernel Memory for System Optimization

Swap Memory: When & How To Use It On Production VMs

Managing Swap to Optimize System Performance

Monitor KSM performance with Netdata

Tracking Kernel Samepage Merging for Optimized Memory Use

Netdata v1.31.0

Unveiling New Features and Improvements for Comprehensive Monitoring