Database Monitoring

Database monitoring tracks the health, latency and resource use of database servers such as PostgreSQL, MySQL, Redis and MongoDB. This hub groups Netdata's database monitoring solution page, ranked lists of monitoring tools for individual databases and blog posts on database performance.

Product

Live Tab - Real-Time Netdata Functions

Get real-time access to Netdata Functions on any agent node: process explorers, database monitoring, network topology & more. See the live demo today!

Solutions

Database Monitoring Software Without Query Languages

Database monitoring for MySQL, PostgreSQL, SQL Server, Oracle & MongoDB with per-second query insights, deadlock detection & AI root cause. Try free today!

Database Monitoring Software With Real-Time Visibility

Monitor every database in real time with per-second precision, AI root-cause detection, and 60-second deployment for full visibility. Book a demo now!

Financial Transaction Monitoring Software

Optimize every transaction with per-second monitoring, faster MTTR, and secure on-prem data for regulated financial environments. Book a demo now!

Infrastructure Health Monitoring Software

Monitor EHRs, medical devices, and telehealth systems with per-second precision and full data sovereignty. Reduce risk and downtime. Book a demo now!

LLM Monitoring Platform With Per-Second Visibility

Get per-second visibility into GPUs & Kubernetes to reduce inference latency, detect anomalies early, & optimize cloud spend for AI workloads. Book a demo!

Guides

Guides overview 9 pages

Cassandra Operations Guides

Practical guides for running, troubleshooting, and monitoring Apache Cassandra in production.

ClickHouse Operations Guides

Practical guides for running, troubleshooting, and monitoring ClickHouse in production.

CockroachDB Operations Guides

Practical guides for running, troubleshooting, and monitoring CockroachDB in production.

Elasticsearch Operations Guides

Practical guides for running, troubleshooting, and monitoring Elasticsearch in production.

Microsoft SQL Server Operations Guides

Practical guides for running, troubleshooting, and monitoring Microsoft SQL Server in production.

MongoDB Operations Guides

Practical guides for running, troubleshooting, and monitoring MongoDB in production.

MySQL Operations Guides

Practical guides for running, troubleshooting, and monitoring MySQL in production.

PostgreSQL Operations Guides

Practical guides for running, troubleshooting, and monitoring PostgreSQL in production.

Redis Operations Guides

Practical guides for running, troubleshooting, and monitoring Redis in production.

Cassandra Operations Guides 24 pages

Open the Cassandra Operations Guides hub

Cassandra Batch Too Large Warning: How To Fix It

Diagnose and remediate Cassandra batch size warnings and coordinator OOM caused by oversized multi-partition batches.

Cassandra commitlog pending tasks: write-path I/O pressure

Diagnose and resolve sustained CommitLog PendingTasks in Apache Cassandra, where commitlog fsync bottlenecks delay write acknowledgments and cascade into dropped mutations.

Cassandra compaction death spiral: when writes outrun compaction throughput

Diagnose and recover from Cassandra compaction backlog when write rates exceed compaction throughput, causing SSTable accumulation, read amplification, and disk saturation.

Cassandra compaction strategies: STCS vs LCS vs TWCS vs UCS

Choose and operate the right Cassandra compaction strategy by understanding the I/O, space, and read amplification tradeoffs between STCS, LCS, TWCS, and UCS.

Cassandra dropped mutations: silent write loss and load shedding

Diagnose and recover from Cassandra dropped mutations, where replicas silently discard writes past queue timeout, causing silent data loss and consistency gaps.

Cassandra dropped reads and other messages: reading nodetool tpstats Dropped

Interpret nodetool tpstats Dropped counters, correlate message types with thread pool saturation, and understand what each scope means for reads, writes, hints, and repairs.

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 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 hint overflow: max_hint_window expiry and silent data divergence

Diagnose and recover from Cassandra hint window expiration, hint accumulation, and the silent data divergence that follows extended replica outages.

Cassandra hints accumulating: hinted handoff backlog and replay storms

Diagnose and resolve Cassandra hinted handoff backlog and replay storms before coordinator disk exhaustion and cascading replica failures.

Cassandra hot partition: when one key saturates a replica set

Diagnose and mitigate hot partitions in Apache Cassandra when a single key concentrates traffic, saturating replicas and spiking tail latency.

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.

Cassandra large partition pathology: Compacting large partition warnings and reads

Diagnose and fix Cassandra large partitions when you see Compacting large partition warnings, read latency spikes, and JVM heap pressure.

Cassandra monitoring checklist: the signals every production cluster needs

A tiered checklist of Cassandra monitoring signals, from survival-level liveness checks to expert-level composite alerting patterns.

Cassandra native transport not running: node UP in gossip but refusing CQL clients

Diagnose why a Cassandra node shows UN in gossip but refuses CQL client connections, and restore native transport safely.

Cassandra OperationTimedOutException: client-side timeouts vs server timeouts

Distinguish client-side driver timeouts from server-side ReadTimeout and WriteTimeout in Cassandra, correlate the right signals, and turn the correct knob.

Cassandra pending compactions growing: the compaction backlog runbook

Diagnose and recover from growing Cassandra compaction backlogs before read latency and disk space spiral out of control.

Cassandra ReadTimeoutException: diagnosing coordinator read timeouts

Diagnose server-side Cassandra read timeouts where the coordinator fails to gather enough replica responses within read_request_timeout_in_ms.

Cassandra repair not running: the silent gap that resurrects deleted data

Detect when Cassandra anti-entropy repair stalls, diagnose why repair fails to complete within gc_grace_seconds, and prevent silent tombstone resurrection.

Cassandra Scanned over N tombstones warning: finding the offending query

Diagnose Cassandra tombstone warnings by identifying the table, partition, and query behind excessive tombstone scans before reads abort or trigger GC pressure.

Cassandra TombstoneOverwhelmingException: reads aborted by tombstone_failure_threshold

Operational guide to diagnosing and fixing Cassandra reads aborted by tombstone_failure_threshold, including per-table diagnosis, compaction, and repair correlation.

Cassandra too many SSTables per table: read amplification and how to fix it

Fix high SSTable counts in Cassandra before read amplification crushes latency. Diagnosis, emergency compaction, and root-cause remediation for LCS and STCS.

Cassandra UnavailableException: not enough replicas for the consistency level

Diagnose and recover from Cassandra UnavailableException when the coordinator cannot satisfy the requested consistency level due to insufficient live replicas.

Cassandra zombie data resurrection: gc_grace_seconds and unrepaired tombstones

Deleted data reappears when tombstones expire before repair reconciles them across replicas. Detect the silent failure and recover safely.

ClickHouse Operations Guides 28 pages

Open the ClickHouse Operations Guides hub

ClickHouse Active Part Count Growing: How To Fix

Operational guide to diagnosing and stopping ClickHouse active part count growth before it triggers insert delays, throttling, or too-many-parts errors.

ClickHouse cannot connect to ZooKeeper/Keeper: diagnosing the coordination layer

Diagnose and recover when ClickHouse loses its ZooKeeper or ClickHouse Keeper coordination layer, including connection checks, 4lw probes, and replica readonly states.

ClickHouse DB::Exception: Too many parts - causes and fixes

Troubleshoot and resolve ClickHouse exception code 252 when inserts fail because a partition has accumulated too many active parts.

ClickHouse DelayedInserts climbing: the warning before too-many-parts

Understand why ClickHouse DelayedInserts climbs, how the insert throttle works, and what to check before inserts start rejecting.

ClickHouse disk space collapse: why merges need free space and how the spiral starts

Why ClickHouse background merges need temporary disk headroom and how crossing the 85-90% threshold triggers a self-reinforcing spiral of stalled merges, accumulating parts, and accelerating consumption.

ClickHouse disk space monitoring: free_space, unreserved_space, and the 80% target

Understand ClickHouse disk space as an operational dependency, not just capacity. Interpret system.disks metrics, maintain merge headroom, and avoid the disk space death spiral.

ClickHouse distributed DDL stuck: ON CLUSTER queries that never finish

Diagnose and fix ON CLUSTER DDL queries that hang or never finish in ClickHouse. Identify stuck hosts, reconcile schema drift, and restore coordination with ZooKeeper or Keeper.

ClickHouse full table scan: partition pruning failures and the primary key

Diagnose why ClickHouse queries scan every row and how to fix partition pruning and primary key misalignment.

ClickHouse Keeper saturation spiral: too many tables, DDL storms, and cluster freeze

Diagnose and break the ZooKeeper/Keeper saturation spiral that turns replicated ClickHouse clusters read-only.

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.

ClickHouse merge death spiral: when parts accumulate faster than merges consolidate

Break the feedback loop where ClickHouse inserts outrun background merges, parts pile up, and writes are delayed or rejected.

ClickHouse merges not keeping up: diagnosing a stalled or starved merge pool

Diagnose why ClickHouse background merges stall, starve, or fall behind, and fix the root cause before parts accumulate into a rejection crisis.

ClickHouse monitoring checklist: the signals every production cluster needs

A production monitoring checklist for ClickHouse organized by maturity level, from survival signals to expert diagnostics.

ClickHouse mutation stuck: parts_to_do not decreasing and how to recover

Diagnose and recover stuck ClickHouse mutations when parts_to_do stops decreasing, including quick checks, root causes, and safe remediation steps.

ClickHouse mutations silently blocking merges: the hidden cause of part growth

Why ALTER UPDATE/DELETE mutations starve the merge pool, how to spot the starvation before parts explode, and what to do about it.

ClickHouse query error rate high: reading exception codes 241, 252, and 999

Triage a ClickHouse query error spike by exception code. Diagnose memory limits, too many parts, ZooKeeper issues, and schema drift using system.query_log and system.events.

ClickHouse query latency P99 spikes: tail latency, hot shards, and cold data

Diagnose and fix ClickHouse P99 query latency spikes caused by tail latency, hot shards, cold data, and resource contention.

ClickHouse Replica is lost: SYSTEM RESTORE REPLICA and recovering a diverged replica

Diagnose and recover a ClickHouse replica that has silently diverged from its peers using SYSTEM RESTART REPLICA and the supported limits of SYSTEM RESTORE REPLICA.

ClickHouse replication lag: absolute_delay, queue_size, and catch-up diagnosis

Diagnose ClickHouse replication lag using system.replicas, system.replication_queue, and background pool signals. Learn to tell a saturated fetch pool from a stuck mutation or a readonly replica.

ClickHouse replication queue stuck: num_tries, last_exception, and dead entries

Diagnose and fix stuck ClickHouse replication queue entries by reading num_tries, last_exception, and entry types instead of relying on delay alone.

ClickHouse small inserts anti-pattern: why single-row inserts melt the merge pool

Understand how single-row and micro-batch inserts create part accumulation in ClickHouse, the signals that expose the pattern, and the client-side fixes that actually work.

ClickHouse Table is in readonly mode: is_readonly on replicated tables and how to fix it

Diagnose and recover replicated ClickHouse tables stuck in readonly mode caused by lost Keeper sessions, coordination failures, or quorum loss.

ClickHouse too many partitions: why over-partitioning multiplies your part count

How high-cardinality partition keys in ClickHouse create thousands of isolated part pools, why parts never merge across partitions, and how this drives per-partition limit violations.

ClickHouse Too many simultaneous queries: max_concurrent_queries and query storms

Diagnose and fix ClickHouse query storms when max_concurrent_queries is reached, including retry amplification and concurrency saturation.

How To Tune ClickHouse Async Inserts: Key Settings

Understand when ClickHouse server-side async insert buffering genuinely reduces part creation versus when it silently relocates too-many-parts risk into an in-memory buffer.

CockroachDB Operations Guides 30 pages

Open the CockroachDB Operations Guides hub

CockroachDB Backup Job Failures: How To Fix Them

How to detect, diagnose, and fix CockroachDB backup failures before they breach your RPO, including stuck jobs and growing backup durations.

CockroachDB certificate expired: TLS handshake failures and online rotation

Detect, diagnose, and recover from expired CockroachDB TLS certificates using online rotation via SIGHUP.

CockroachDB changefeed lag: changefeed_max_behind_nanos and the GC time bomb

Diagnose and fix CockroachDB changefeed lag before protected timestamps block MVCC garbage collection and fill your disk.

CockroachDB clock skew cascade: how shared NTP drift causes quorum loss

Diagnose and resolve CockroachDB clock skew cascades where shared NTP drift causes multiple node self-terminations and quorum loss.

CockroachDB clock synchronization error: this node is more than 500ms away from at least half of the known nodes

Diagnose and fix the CockroachDB clock synchronization error that causes nodes to self-terminate when clock drift exceeds the max-offset threshold.

CockroachDB clock_offset_meannanos high: catching clock drift before self-termination

How to diagnose and prevent high clock_offset_meannanos in CockroachDB before clock drift causes node self-termination and quorum loss.

CockroachDB compaction backlog growing: when Pebble can't keep pace with writes

Diagnose a growing Pebble compaction backlog in CockroachDB before it triggers write stalls, and learn how to restore balance between write ingestion and compaction throughput.

CockroachDB connection storm after failover: reconnect stampedes and surviving-node overload

Diagnose and mitigate reconnect stampedes that overload surviving CockroachDB nodes after failover, with metrics, quick checks, and client pool tuning.

CockroachDB consistency check failed: checksum mismatches and confirmed corruption

Operational reference for diagnosing and responding to CockroachDB consistency check failures, checksum mismatches, and confirmed data corruption.

CockroachDB context deadline exceeded: timeouts, slow ranges, and overload

Diagnose CockroachDB context deadline exceeded errors by tracing KV exec latency, round-trip latency, L0 sublevels, and admission control queues to find the slow layer.

CockroachDB CPU saturation: Raft ticking, SQL execution, and the per-node ceiling

Diagnose CockroachDB CPU saturation by separating Raft tick overhead, SQL execution, GC pressure, and I/O-bound system time from cluster-wide averages.

CockroachDB detecting hot ranges: per-range QPS, CPU asymmetry, and the Hot Ranges page

How to detect hot ranges in CockroachDB using per-node CPU asymmetry and the DB Console Hot Ranges/Top Ranges page.

CockroachDB disk stall detected: storage_disk_stalled and node self-termination

Diagnose and resolve CockroachDB storage_disk_stalled alerts before the node self-terminates to prevent data inconsistency.

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 LSM compaction death spiral: L0 sublevels, read amplification, and write stalls

Diagnose and break the LSM compaction death spiral in CockroachDB by monitoring L0 sublevels, read amplification, and write stalls before nodes lose leases.

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 monitoring checklist: the signals every production cluster needs

A production monitoring reference for CockroachDB covering the signals every cluster needs, organized by maturity level from survival to expert.

CockroachDB node liveness failure: heartbeats, lease redistribution, and flapping

Diagnose and fix CockroachDB node liveness failures, from disk stalls and GC pauses to network partitions and flapping 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.

CockroachDB Pebble write stalls: when the storage engine refuses writes

Diagnose and resolve CockroachDB Pebble write stalls when the storage engine pauses writes due to LSM compaction debt.

CockroachDB ReadWithinUncertaintyInterval restarts: the near-diagnostic signal of clock skew

Diagnose and resolve ReadWithinUncertaintyInterval restarts in CockroachDB, the near-diagnostic signal of clock skew between nodes.

CockroachDB replica unavailable: lost quorum and stuck Raft groups

Diagnose and resolve CockroachDB replica unavailable errors, lost Raft quorum, and stuck Raft groups causing range unavailability.

CockroachDB result is ambiguous: ambiguous commit errors and how to handle them

Diagnose and handle CockroachDB result is ambiguous errors (code 40003), from leaseholder changes to network timeouts, with practical retry and idempotency guidance.

CockroachDB RETRY_WRITE_TOO_OLD: the most common contention restart and how to kill it

Diagnose and eliminate CockroachDB writetooold transaction restarts caused by hot keys, sequential writes, and wide transactions under SERIALIZABLE isolation.

CockroachDB SQL error rate: XX000 internal errors and error-code triage

Triage CockroachDB SQL error rates by PostgreSQL error code, distinguish XX000 internal errors from retriable failures, and know when to page.

CockroachDB store is full: emergency disk recovery and why deletes don't free space

Emergency recovery procedures when CockroachDB stores run out of disk space, and why SQL DELETE operations do not immediately reclaim space.

CockroachDB too many connections: sql_conns, pooling, and goroutine pressure

Diagnose and resolve connection pressure in CockroachDB using sql_conns, goroutine counts, and file descriptor metrics before they cascade into node failure.

CockroachDB TransactionRetryWithProtoRefreshError: RETRY_SERIALIZABLE causes and fixes

Diagnose and fix CockroachDB RETRY_SERIALIZABLE errors by distinguishing writetooold, readwithinuncertainty, and txnpush causes and implementing proper retry logic.

CockroachDB under-replicated ranges: ranges_underreplicated and the healing margin

Diagnosing CockroachDB under-replicated ranges, understanding the healing margin, and configuring alerting that separates expected recovery from dangerous fault tolerance loss.

How To Fix CockroachDB Admission Control Throttling

Diagnose CockroachDB admission control throttling across its five queues, correlate store-write depth with LSM health, and determine when queuing is protective versus capacity-limiting.

Elasticsearch Operations Guides 16 pages

Open the Elasticsearch Operations Guides hub

Elasticsearch All Shards Failed: How To Fix It

Diagnose and fix Elasticsearch search_phase_execution_exception when all shards fail, distinguishing data unavailability from query errors and resource exhaustion.

Elasticsearch cluster health red: unassigned primaries and how to recover

Diagnose and recover from a red Elasticsearch cluster when primary shards are unassigned, including allocation explain, disk watermarks, and manual reroute.

Elasticsearch cluster health yellow: unassigned replicas vs real allocation blocks

Distinguish benign yellow cluster states from real allocation blockers. Diagnose unassigned replicas, disk watermarks, and shard allocation failures in Elasticsearch.

Elasticsearch disk watermark cascade: from low watermark to cluster-wide read-only

Operational guide to diagnosing and recovering from the Elasticsearch disk watermark cascade: low, high, and flood stage thresholds, read-only index blocks, and relocation storms.

Elasticsearch EsRejectedExecutionException: write thread pool rejections and HTTP 429

Diagnose and fix Elasticsearch write thread pool rejections that surface as EsRejectedExecutionException and HTTP 429 responses.

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 ILM stuck: indices not rolling over, shrinking, or deleting

Diagnose and unstick Elasticsearch Index Lifecycle Management when indices fail to advance through rollover, shrink, or delete actions.

Elasticsearch indexing rate dropped to zero: where the write path stalls

Diagnose why Elasticsearch indexing stops despite active ingestion. Covers write thread pool saturation, merge storms, ingest pipeline bottlenecks, unassigned primaries, circuit breakers, and read-only disk blocks.

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 Limit of total fields [1000] in index has been exceeded — mapping explosion

Diagnose and fix the Elasticsearch illegal_argument_exception when dynamic mapping causes the index total fields limit of 1000 to be exceeded.

Elasticsearch mapper_parsing_exception: type conflicts and failed document indexing

Fix mapper_parsing_exception errors in Elasticsearch caused by type conflicts, strict mapping, and malformed fields. Learn to detect, diagnose, and reindex safely.

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 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 unassigned shards: reading allocation explain and fixing each reason

Diagnose and resolve unassigned shards in Elasticsearch by reading the allocation explain API, interpreting unassigned.reason values, and applying targeted fixes per failure mode.

Fix Elasticsearch CircuitBreakingException Errors

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

Microsoft SQL Server Operations Guides 19 pages

Open the Microsoft SQL Server Operations Guides hub

Microsoft SQL Server monitoring checklist: the signals every production instance needs

A production monitoring checklist for Microsoft SQL Server covering instance responsiveness, database state, transaction log usage, PLE, wait stats, blocking, TempDB, I/O stall, backups, and AG health.

SQL Server AG send and redo queues growing: replication lag and failover RTO

Diagnose growing log_send_queue_size and redo_queue_size in Always On Availability Groups, estimate failover RTO, and resolve replication lag.

SQL Server Availability Group not synchronizing: NOT_HEALTHY replicas and failover risk

Diagnose and resolve SQL Server Availability Group replicas stuck in NOT_HEALTHY or DISCONNECTED states, and understand when failover capability is actually compromised.

SQL Server backup freshness: the recovery point you only discover you lack during an incident

How to measure SQL Server backup freshness from msdb.dbo.backupset, why job status alone is insufficient, and the silent failure modes that leave databases unprotected.

SQL Server blocking chains: finding the head blocker before workers run out

Diagnose and resolve SQL Server blocking chains before they drain the worker thread pool into THREADPOOL waits.

SQL Server CPU utilization high: telling query load apart from a bad plan

SQL Server at 100% CPU is not automatically an incident. Learn how to split SQL Server CPU from other-process CPU, tell legitimate load from a bad plan, and alert on the signals that actually matter.

SQL Server CXPACKET and CXCONSUMER waits: parallelism, MAXDOP, and what is actually wrong

How to read CXPACKET and CXCONSUMER wait stats in SQL Server, when high values are normal, and how to fix the real causes: skewed parallel work, missing indexes, and bad MAXDOP or cost threshold defaults.

SQL Server database in SUSPECT or RECOVERY_PENDING: an offline database and how to recover it

Diagnose and recover a SQL Server database stuck in SUSPECT, RECOVERY_PENDING, or EMERGENCY without jumping straight to data-loss repair.

SQL Server Error 1205: transaction was deadlocked and chosen as the deadlock victim

Diagnose SQL Server deadlocks: capture the xml_deadlock_report, identify the victim, and fix the root cause.

SQL Server Error 18456: login failed for user, and what the state code means

How to read the real cause of SQL Server login failures from the state code in the error log, and what to do about each state.

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 Error 823 and 824: I/O and logical consistency errors

Triage SQL Server severity-24 I/O errors: hard OS-level failures (823), logical consistency and checksum errors (824), and the 825 read-retry canary, plus DBCC CHECKDB, suspect_pages, and restore-first response.

SQL Server Error 825: read-retry succeeded and the disk is failing

SQL Server Error 825 means a disk read eventually succeeded after retries, but the storage medium is deteriorating and a hard 823/824 is coming.

SQL Server Error 9002: the transaction log for the database is full

Diagnose and fix SQL Server error 9002 by reading log_reuse_wait_desc first, then resolving the specific blocker: log backups, open transactions, AG lag, or replication.

SQL Server instance down: no response on port 1433 and where to look first

Triage a SQL Server instance that fails connectivity probes on port 1433 by separating true service outages from worker exhaustion, listener misconfiguration, and database-scoped failures.

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.

SQL Server SOS_SCHEDULER_YIELD waits: CPU scheduler pressure explained

How to read SOS_SCHEDULER_YIELD waits, separate real CPU pressure from benign yielding, and diagnose VM steal, bad plans, and compilation storms.

SQL Server TempDB full: the shared scratch database that halts every query

Troubleshoot a full TempDB on SQL Server: find which consumer (user objects, internal spills, version store) is eating space, stop the bleeding, and prevent recurrence.

SQL Server THREADPOOL waits: worker thread exhaustion and refused connections

How to diagnose and resolve SQL Server THREADPOOL waits when worker thread exhaustion makes the instance refuse connections while CPU and I/O sit idle.

MongoDB Operations Guides 26 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 Balancer Stuck On Jumbo Chunks: Fix It

Diagnose and fix permanent shard imbalance in MongoDB caused by a stuck balancer or jumbo chunks that cannot migrate.

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 checkpoint duration climbing: diagnosing slow WiredTiger checkpoints

Diagnose and fix climbing WiredTiger checkpoint duration before it exceeds the 60-second interval and freezes writes.

MongoDB checkpoint stall write freeze: when all writes stop with no error

Troubleshoot the WiredTiger checkpoint stall that silently blocks all MongoDB writes with no errors, leaving reads partially functional.

MongoDB connection churn: high totalCreated rate and thread creation overhead

Diagnose and fix MongoDB connection churn where a climbing totalCreated delta with stable current connections drives thread creation overhead and latency.

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 journal sync latency high: the storage signal that warns 60 seconds early

Detect, diagnose, and fix high WiredTiger journal sync latency in MongoDB before it stalls j:true and w:majority writes.

MongoDB lock wait times: collection and metadata lock contention during DDL

Diagnose and fix high MongoDB collection and metadata lock wait times caused by DDL operations such as createIndex, dropIndex, and collMod.

MongoDB long-running operations: finding and killing the query holding a ticket

Find and terminate long-running MongoDB operations that are blocking others by holding WiredTiger tickets, using currentOp, killOp, and related diagnostic signals.

MongoDB monitoring checklist: the signals every production cluster needs

A leveled checklist of production MongoDB monitoring signals covering liveness, replication, WiredTiger cache, tickets, connections, and disk saturation.

MongoDB no primary / election storm: repeated elections and write outages

Diagnose and stop MongoDB replica set election storms where primaries repeatedly step down, causing rolling 2-12 second write outages.

MongoDB not master error: writes hitting a non-primary node after failover

Troubleshoot and fix MongoDB NotWritablePrimary errors that occur when applications write to a non-primary node after failover or election.

MongoDB not primary and secondaryOk=false: reading from a secondary and how to fix it

Fix MongoDB NotPrimaryNoSecondaryOk errors when clients route reads to secondaries without the correct read preference, and prevent stale topology failures after failover.

MongoDB operation exceeded time limit (MaxTimeMSExpired): maxTimeMS and killed operations

Diagnose MongoDB MaxTimeMSExpired errors. Understand why maxTimeMS kills operations, how to distinguish server-side timeouts from client socket timeouts, and how to find root causes with currentOp and the slow query log.

MongoDB oplog window collapse: secondaries falling off and forced full resync

Diagnose and fix MongoDB oplog window collapse when write surges shrink the replication window and force secondaries into RECOVERING state.

MongoDB oplog window too small: sizing the oplog for your write volume

Size and monitor the MongoDB oplog window to prevent secondaries from falling off and forcing full resyncs. Production rules, resize commands, and thresholds.

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 rollback after failover: silent data loss and the rollback directory

Understand MongoDB rollback after failover, recover data from the rollback directory, and prevent silent data loss with majority write concern.

MongoDB silent index regression: when a dropped index quietly becomes a collection scan

Diagnose and fix the failure mode where MongoDB queries silently switch to collection scans after an index drop or planner regression, causing read latency to grow with collection size.

MongoDB slow query COLLSCAN: collection scans and the missing index

Diagnose and fix MongoDB collection scans (COLLSCAN) that cause slow queries by identifying missing indexes, query plan regressions, and inefficient predicates.

MongoDB ticket exhaustion: WiredTiger read/write tickets and queued operations

Diagnose and fix MongoDB WiredTiger ticket exhaustion when read or write tickets approach zero and operations queue.

MongoDB too stale to catch up: secondary stuck in RECOVERING and how to resync

Diagnose and recover a MongoDB secondary that has fallen past the primary's oplog window, is stuck in RECOVERING, and requires a full initial sync.

MongoDB WiredTiger cache dirty ratio high: the leading indicator nobody watches

Learn why WiredTiger dirty ratio is a stronger leading indicator than cache fill, how to diagnose it before latency spikes, and what to fix.

MongoDB WiredTiger cache pressure cascade: eviction stalls and latency spikes

Diagnose and break the MongoDB WiredTiger cache pressure cascade before eviction stalls and latency spikes bring down your replica set.

MySQL Operations Guides 30 pages

Open the MySQL Operations Guides hub

MySQL Aborted Connections: Causes And Fixes

Diagnose rising MySQL Aborted_connects and Aborted_clients counters. Distinguish handshake failures from dropped connections, find the root cause, and fix it without restarting the server.

MySQL Binary Log Disk Full: How To Fix It

Diagnose and fix MySQL binary log disk exhaustion caused by missing expiry, lagging replicas, or oversized transactions. Safe manual purge procedures and prevention.

MySQL connection exhaustion: detection, diagnosis, and prevention

Detect, diagnose, and prevent MySQL connection exhaustion before application errors cascade into an outage.

MySQL ERROR 1040 (HY000): Too many connections - causes and fixes

Troubleshoot MySQL ERROR 1040 (HY000) by distinguishing connection leaks from genuine overload, using Threads_running, Threads_connected, and Connection_errors_max_connections.

MySQL ERROR 1045 (28000): Access denied for user - diagnosis

Diagnose MySQL ERROR 1045 (28000) caused by credential mismatches, user@host restrictions, authentication plugin incompatibility, and host cache blocking.

MySQL ERROR 1205: Lock wait timeout exceeded; try restarting transaction

Diagnose and fix MySQL ER_LOCK_WAIT_TIMEOUT. Find blocking transactions, understand statement-level rollback, and prevent row lock contention in production.

MySQL ERROR 1213: Deadlock found when trying to get lock; try restarting transaction

Diagnose and resolve MySQL ERROR 1213 deadlocks in InnoDB. Covers victim selection, gap-lock interaction, diagnostic commands, and prevention.

MySQL ERROR 2006/2013: MySQL server has gone away -- causes and fixes

Troubleshoot MySQL ERROR 2006 and 2013 by distinguishing idle timeout closures from crashes, packet limits, and network timeouts.

MySQL full table scans: Handler_read_rnd_next and the missing index

Diagnose unexpected full table scans in MySQL by correlating Handler_read_rnd_next step-changes with Slow_queries, then isolate the offending query and fix the index coverage.

MySQL Got error 28 from storage engine / No space left on device — recovery

Recover from MySQL errno 28 disk-full conditions by identifying whether binlogs, redo logs, tmpdir, or relay logs consumed the space, and apply the right fix without causing data loss.

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 checkpoint age: the redo log capacity signal nobody watches

How to monitor InnoDB checkpoint age in MySQL 8.0+, understand the redo log capacity cliff edge, and avoid the write stalls that take production down.

MySQL InnoDB history list length growing: purge lag explained

Understand how InnoDB purge lag works, why the history list length grows, and how MVCC read views turn a single idle transaction into fleet-wide slowdown.

MySQL InnoDB redo log checkpoint stall: when all writes freeze

Diagnose and fix InnoDB redo log checkpoint stalls that synchronously freeze all MySQL writes when checkpoint age exceeds redo capacity.

MySQL InnoDB row lock contention: finding who blocks whom

Diagnose InnoDB row lock contention in MySQL 8.0+ and 5.7 by mapping blocking transactions with performance_schema.data_lock_waits, sys.innodb_lock_waits, and the right status metrics.

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 innodb_redo_log_capacity sizing: how big should the redo log be

Size the MySQL InnoDB redo log to avoid checkpoint stalls. Covers 8.0.30+ dynamic capacity, headroom calculations, and flush tuning.

MySQL long-running transactions: detecting and killing the silent blocker

Detect, diagnose, and kill idle InnoDB transactions that silently hold locks and block purge, causing lock waits and history list growth.

MySQL metadata lock cascade: how one ALTER TABLE freezes a whole table

Diagnose and break a metadata lock cascade when DDL blocks behind a long transaction and connection pools fill with waiting DML.

MySQL monitoring checklist: the signals every production instance needs

A tiered operational reference of the core MySQL signals every production instance needs, from survival metrics to expert-level lock diagnostics.

MySQL online DDL still blocking: ALGORITHM, LOCK, and the copy phase

Why MySQL online DDL still blocks despite ALGORITHM=INPLACE/INSTANT and LOCK=NONE, and how metadata locks cause copy-phase stalls.

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.

MySQL purge lag from an idle transaction: the slow bleed

Diagnose and fix InnoDB purge lag caused by a single idle transaction holding an MVCC read view, leading to unbounded history list growth and gradual query degradation.

MySQL query plan regression: when a query gets slow after a deploy or ANALYZE

Diagnose and fix sudden MySQL query slowdowns caused by bad execution plans after deployments, ANALYZE TABLE, schema changes, or upgrades.

MySQL Replica_IO_Running / Replica_SQL_Running not Yes: replication stopped

Diagnose why MySQL replication I/O or SQL threads stop, read SHOW REPLICA STATUS errors, and recover safely.

MySQL replication lag spiral: Seconds_Behind_Source growing without bound

Diagnose and stop a MySQL replication lag death spiral when the replica cannot keep up, relay logs grow, and Seconds_Behind_Source increases monotonically.

MySQL slow commits with idle CPU: redo and binlog fsync pressure

Diagnose and fix MySQL commit latency when CPU is idle but transactions stall on redo log and binary log fsync pressure.

MySQL slow queries: from Slow_queries to the slow log to the fix

Diagnose MySQL slow queries when Slow_queries climbs, the slow log is disabled, or long_query_time hides real problems. Read-only checks, ratio analysis, and targeted fixes.

MySQL Waiting for table metadata lock: diagnosing the DDL stall

Diagnose MySQL sessions stuck in Waiting for table metadata lock, identify the blocking transaction, and break the DDL stall before connection exhaustion.

PostgreSQL Operations Guides 25 pages

Open the PostgreSQL Operations Guides hub

PostgreSQL autovacuum blocked by long-running transaction: detection and fix

Detect when long-running transactions, replication slots, or standby feedback pin the PostgreSQL xmin horizon and block autovacuum from reclaiming dead tuples.

PostgreSQL autovacuum not running: detection, causes, and fixes

Detect when PostgreSQL autovacuum is blocked or misconfigured, diagnose the root cause, and fix it before bloat and XID wraparound force an outage.

PostgreSQL autovacuum tuning: per-table thresholds for high-churn workloads

Configure per-table autovacuum thresholds, memory, and I/O throttling to control bloat and freeze progress on high-churn PostgreSQL tables.

PostgreSQL Blocking Queries: Finding The Root Blocker In A Lock Cascade

Diagnose and resolve PostgreSQL lock cascades by finding the root blocker using pg_blocking_pids, pg_locks, and recursive CTEs.

PostgreSQL checkpoint storms: detection, causes, and tuning

Detect and fix PostgreSQL checkpoint storms before they stall your queries. Covers forced vs timed checkpoints, max_wal_size tuning, and safe tuning tradeoffs.

PostgreSQL Connection Exhaustion: Detection, Diagnosis & Prevention

Detect, diagnose, and prevent PostgreSQL connection exhaustion caused by pool leaks, idle-in-transaction sessions, and missing connection limits.

PostgreSQL dead tuples piling up: why autovacuum can't keep up

Diagnose why PostgreSQL dead tuple counts grow faster than autovacuum can reclaim them, and fix the root cause before bloat triggers an outage.

PostgreSQL deadlock detected: how to diagnose and prevent deadlocks

Diagnose PostgreSQL deadlocks, read wait-for graphs, fix inverted lock ordering, and prevent recurrence with log_lock_waits and SKIP LOCKED.

PostgreSQL ERROR: Could Not Obtain Lock — Diagnosis & Recovery

Diagnose and recover from PostgreSQL lock contention errors, including NOWAIT failures, lock timeout cancellations, and DDL blocking locks.

PostgreSQL FATAL: Too Many Connections - Causes & Fixes

Diagnose and resolve PostgreSQL connection exhaustion. Covers max_connections, idle-in-transaction, PgBouncer pooling, and superuser reserved connections.

PostgreSQL frozen XID monitoring: catching wraparound 6 months early

Monitor datfrozenxid, relfrozenxid, and multixact age with tiered thresholds to catch PostgreSQL transaction ID wraparound while you still have months of runway.

PostgreSQL Idle In Transaction: Detecting & Killing Zombie Sessions

Detect and terminate PostgreSQL sessions stuck in idle in transaction before they block VACUUM, trigger bloat, and exhaust connections.

PostgreSQL index bloat: detection and REINDEX CONCURRENTLY recovery

Detect B-tree index bloat in PostgreSQL using pgstatindex and recover online with REINDEX CONCURRENTLY without locking the table.

PostgreSQL logical replication failures: conflicts, schema drift, and recovery

Diagnose and resolve PostgreSQL logical replication failures including subscriber conflicts, schema drift gaps, replica identity misconfiguration, and recovery procedures.

PostgreSQL missing indexes: detection from pg_stat_statements and logs

Detect missing indexes in PostgreSQL using pg_stat_user_tables, pg_stat_statements, auto_explain, and HypoPG without disrupting production.

PostgreSQL Monitoring Checklist: The Signals Every Production Database Needs

A staged monitoring checklist that maps the essential PostgreSQL signals, metrics, and thresholds to operational maturity levels, from basic health to predictive operations.

PostgreSQL pg_wal directory full: causes and emergency recovery

Diagnose unbounded WAL growth in PostgreSQL and recover safely when pg_wal fills the disk, including archive_command failures, replication slot retention, and emergency cleanup.

PostgreSQL replication lag: detection, diagnosis, and fixes

Detect, diagnose, and fix PostgreSQL streaming replication lag before it turns a routine failover into a data-loss event.

PostgreSQL replication slot bloat: when a stale slot fills the disk

Detect when a stale or orphaned PostgreSQL replication slot retains WAL and fills disk, diagnose the root cause, and recover safely.

PostgreSQL Slow Queries: Diagnosis From Log To Plan To Fix

A practical troubleshooting guide for diagnosing PostgreSQL slow queries using pg_stat_statements, log_min_duration_statement, auto_explain, and execution plan analysis.

PostgreSQL table bloat: detection, measurement, and remediation

Detect, accurately measure, and safely remediate PostgreSQL table bloat using pgstattuple, pg_repack, and autovacuum tuning.

PostgreSQL transaction ID wraparound: detection and emergency recovery

Detect transaction ID wraparound before it halts writes, then recover safely with VACUUM FREEZE.

PostgreSQL: checkpoints are occurring too frequently -- what to tune

Diagnose and fix frequent PostgreSQL checkpoints. Learn when to raise max_wal_size, adjust checkpoint_timeout, and spread I/O with checkpoint_completion_target.

PostgreSQL: database is not accepting commands to avoid wraparound data loss

Recover from PostgreSQL's transaction ID wraparound shutdown. Learn why writes are blocked, how to clear blockers, and the correct VACUUM procedure for modern versions.

Reading EXPLAIN ANALYZE: the operator's guide to PostgreSQL query plans

Learn to read PostgreSQL EXPLAIN ANALYZE output like an SRE. Understand actual versus estimated rows, buffer hits, the loops multiplier, and common misreadings that waste tuning effort.

Redis Operations Guides 13 pages

Open the Redis Operations Guides hub

MISCONF Redis is configured to save RDB snapshots - what it means and how to fix it

Fix the Redis MISCONF error that blocks writes when a background RDB save fails. Diagnose root causes, recover safely, and understand the stop-writes-on-bgsave-error guard.

Redis aof_last_write_status:err: AOF write failures and recovery

Diagnose and recover when Redis AOF writes fail, including disk full, I/O errors, and the path from aof_last_write_status:err back to ok.

Redis cluster_slots_pfail > 0: impending node failure in a cluster

Investigate Redis Cluster PFAIL before it escalates to FAIL. Learn the gossip mechanism, quorum rules, zombie states, and how to distinguish transient pauses from real node failure.

Redis CLUSTERDOWN / cluster_state:fail: slot coverage and recovery

Diagnose and recover when Redis Cluster reports cluster_state:fail or clients see CLUSTERDOWN due to missing hash slot coverage.

Redis CPU saturation: hitting the single-core throughput ceiling

Diagnose Redis main-thread CPU saturation. Learn why single-threaded command execution creates a linear latency ramp, which metrics expose it, and how to relieve the bottleneck.

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 KEYS command blocking production: why to replace it with SCAN

Diagnose and fix Redis production outages caused by the KEYS command blocking the single-threaded event loop, and replace it with SCAN.

Redis MASTERDOWN / master_link_status:down: replication link broken

Diagnose and fix a Redis replica when master_link_status flips to down, the replication link breaks, and stale reads are served.

Redis max number of clients reached: maxclients and rejected_connections

Diagnose and resolve Redis maxclients exhaustion, rejected_connections spikes, and connection pool leaks with CLIENT LIST, CLIENT KILL, and ulimit tuning.

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 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 replication lag: detection, diagnosis, and fixes

Troubleshoot Redis replication lag by measuring byte-level offsets, identifying resource bottlenecks on replicas, and preventing full resync cascades caused by undersized backlogs.

Academy

PostgreSQL 17 Cardinality Estimation & Tuning Tips

A deep dive into how the query planner thinks and how to leverage new features for smarter- faster queries

Using FOR UPDATE SKIP LOCKED For Queue Workflows

How a single SQL clause can transform your database into a high-throughput- parallel-processing task queue

How Autovacuum Causes PostgreSQL Deadlocks

A deep dive into the locking behavior of autovacuum and how to tune it to prevent it from conflicting with your application

Early Deadlock Detection With pg_stat_kcache & eBPF

A proactive monitoring strategy to identify and resolve the precursors to deadlocks before they impact your application

Short vs Long Transactions In PostgreSQL Benchmarks

How holding locks for milliseconds longer can cripple your database- and how to prove it with a repeatable benchmark

A Comprehensive Guide To Database Performance Optimization

Unlock peak database efficiency and reliability with proven strategies for performance tuning and optimization- Say goodbye to bottlenecks and hello to speed.

What Is Database Concurrency? Problems & Control Techniques

Managing simultaneous database access without compromising data integrity

All Types Of Databases: Advantages & Examples

Explore The Different Types Of Databases, Their Benefits & Examples To Find The Right Fit For Your Needs

What Is Database Clustering? Types & Benefits

Enhance Performance, Scalability & Availability Of Databases

Effective Strategies for Managing PostgreSQL Deadlocks

Best Practices and Techniques to Prevent and Resolve Deadlocks in PostgreSQL

How to Troubleshoot Slow Queries in MongoDB

A Beginner’s Guide to Optimizing MongoDB Performance

4D Server Monitoring

Learn everything about monitoring & troubleshooting 4D Server, what metrics are important to monitor and why, and how to monitor 4D Server with Netdata.

AWS RDS Monitoring

Learn everything about monitoring & troubleshooting AWS RDS, what metrics are important to monitor and why, and how to monitor AWS RDS with Netdata.

Cassandra Monitoring

Learn everything about monitoring & troubleshooting Cassandra, what metrics are important to monitor and why, and how to monitor Cassandra with Netdata.

ClickHouse Monitoring

Learn everything about monitoring & troubleshooting ClickHouse, what metrics are important to monitor and why, and how to monitor ClickHouse with Netdata.

ClusterControl CMON Monitoring

Learn everything about monitoring & troubleshooting ClusterControl CMON, what metrics are important to monitor and why, and how to monitor ClusterControl CMON with Netdata.

CockroachDB Monitoring

Learn everything about monitoring & troubleshooting CockroachDB, what metrics are important to monitor and why, and how to monitor CockroachDB with Netdata.

Couchbase Monitoring

Learn everything about monitoring & troubleshooting Couchbase, what metrics are important to monitor and why, and how to monitor Couchbase with Netdata.

CouchDB Monitoring

Learn everything about monitoring & troubleshooting CouchDB, what metrics are important to monitor and why, and how to monitor CouchDB with Netdata.

Elasticsearch Monitoring

Learn everything about monitoring & troubleshooting Elasticsearch, what metrics are important to monitor and why, and how to monitor Elasticsearch with Netdata.

etcd Monitoring

Learn everything about monitoring & troubleshooting etcd, what metrics are important to monitor and why, and how to monitor etcd with Netdata.

HANA Monitoring

Learn everything about monitoring & troubleshooting HANA, what metrics are important to monitor and why, and how to monitor HANA with Netdata.

InfluxDB Monitoring

Learn everything about monitoring & troubleshooting InfluxDB, what metrics are important to monitor and why, and how to monitor InfluxDB with Netdata.

MaxScale Monitoring

Learn everything about monitoring & troubleshooting MaxScale, what metrics are important to monitor and why, and how to monitor MaxScale with Netdata.

Microsoft SQL Server (MSSQL) Monitoring

Discover comprehensive MSSQL monitoring, vital metrics, and how to use Netdata for efficient management. Find out more now.

MongoDB Monitoring

Learn everything about monitoring & troubleshooting MongoDB, what metrics are important to monitor and why, and how to monitor MongoDB with Netdata.

MySQL Monitoring

Learn everything about monitoring & troubleshooting MySQL, what metrics are important to monitor and why, and how to monitor MySQL with Netdata.

Patroni Monitoring

Learn everything about monitoring & troubleshooting Patroni, what metrics are important to monitor and why, and how to monitor Patroni with Netdata.

pgBackRest Monitoring

Learn everything about monitoring & troubleshooting pgBackRest, what metrics are important to monitor and why, and how to monitor pgBackRest with Netdata.

PgBouncer Monitoring

Learn everything about monitoring & troubleshooting PgBouncer, what metrics are important to monitor and why, and how to monitor PgBouncer with Netdata.

Pgpool-II Monitoring

Learn everything about monitoring & troubleshooting Pgpool-II, what metrics are important to monitor and why, and how to monitor Pgpool-II with Netdata.

Pika Monitoring

Learn everything about monitoring & troubleshooting Pika, what metrics are important to monitor and why, and how to monitor Pika with Netdata.

PostgreSQL Monitoring

Find out about monitoring & troubleshooting PostgreSQL, what metrics are important to monitor and why, and how to monitor PostgreSQL with Netdata.

ProxySQL Monitoring

Learn everything about monitoring & troubleshooting ProxySQL, what metrics are important to monitor and why, and how to monitor ProxySQL with Netdata.

Redis Monitoring

Learn everything about monitoring & troubleshooting Redis, what metrics are important to monitor and why, and how to monitor Redis with Netdata.

RethinkDB Monitoring

Learn everything about monitoring & troubleshooting RethinkDB, what metrics are important to monitor and why, and how to monitor RethinkDB with Netdata.

Riak KV Monitoring

Learn everything about monitoring & troubleshooting Riak KV, what metrics are important to monitor and why, and how to monitor Riak KV with Netdata.

Solr Monitoring

Learn everything you need to know about monitoring & troubleshooting Solr, what metrics are important to monitor and why, and how to monitor Solr with Netdata.

SQL Database agnostic Monitoring

Learn everything about monitoring & troubleshooting SQL databases, what metrics are important to monitor and why, and how to monitor SQL databases with Netdata.

Typesense Monitoring

Learn everything about monitoring & troubleshooting Typesense, what metrics are important to monitor and why, and how to monitor Typesense with Netdata.

Vertica Monitoring

Learn everything about monitoring & troubleshooting Vertica, what metrics are important to monitor and why, and how to monitor Vertica with Netdata.

Warp10 Monitoring

Learn everything about monitoring & troubleshooting Warp10, what metrics are important to monitor and why, and how to monitor Warp10 with Netdata.

YugabyteDB Monitoring

Learn everything about monitoring & troubleshooting YugabyteDB, what metrics are important to monitor and why, and how to monitor YugabyteDB with Netdata.

Resources

10 Best Database Monitoring Tools (2027 Comparison)

Compare the 10 best database monitoring tools for 2027: query-level depth, engine coverage, pricing shape, and deployment, ranked by practitioners.

10 Best Microsoft SQL Server Monitoring Tools (2026)

We ranked the 10 best Microsoft SQL Server monitoring tools on wait statistics, query depth, alerting, and cost transparency. See which fits your fleet.

10 Best PostgreSQL Monitoring Tools for 2026

An honest ranking of the 10 best PostgreSQL monitoring tools for 2026: query depth, collection granularity, deployment burden, and pricing shape compared.

11 Best Elasticsearch Monitoring Tools Ranked (2026)

Compare the 11 best Elasticsearch monitoring tools for 2026: cluster health, JVM, thread pools, pricing shapes, and which tool actually fits your stack.

8 Best PgBouncer Monitoring Tools (2026)

Compare the 8 best PgBouncer monitoring tools for 2026, ranked on native pool metrics, per-second resolution, setup effort, alerting, and pricing.

Best Cassandra Monitoring Tools: 10 Ranked (2026)

We ranked 10 Cassandra monitoring tools on JMX metric depth, collection resolution, alerting, and pricing predictability so you pick the right fit.

Best ClickHouse Monitoring Tools: 10 Ranked for 2026

The 10 best ClickHouse monitoring tools ranked for 2026: coverage depth, data resolution, alerting, and real cost shape, from Netdata to Site24x7.

Best Memcached Monitoring Tools in 2026: 10 Ranked

The 10 best Memcached monitoring tools ranked by metric depth, collection resolution, alerting quality, and pricing predictability for production cache fleets.

Best MongoDB Monitoring Tools (10 Ranked for 2026)

We ranked 10 best MongoDB monitoring tools on metric depth, collection granularity, query-level insight and cost of ownership. See which fits your stack.

Best MySQL Monitoring Tools: 10 Options Ranked for 2026

We rank the 10 best MySQL monitoring tools for 2026, comparing query analytics, replication visibility, deployment flexibility, and total cost of ownership.

Best Oracle Database Monitoring Tools: 10 Ranked for 2026

The 10 best Oracle database monitoring tools ranked on Oracle depth, granularity, full-stack correlation, and pricing predictability, from Netdata to Zabbix.

Best ProxySQL Monitoring Tools: 6 Ranked for 2026

The 6 best ProxySQL monitoring tools ranked by connection pool depth, collection resolution, backend health alerting, and cost shape, from Netdata to Zabbix.

Best Redis Monitoring Tools: 10 Options Ranked for 2026

The 10 best Redis monitoring tools ranked for 2026, compared on metric depth, collection resolution, alerting, setup effort, and pricing for real fleets.

The 10 Best CockroachDB Monitoring Tools for 2026

Compare the 10 best CockroachDB monitoring tools for 2026: Netdata, Datadog, Grafana, Prometheus, DBmarlin and more, ranked on depth, alerting and pricing.

Webinar: Live Database & Network Diagnostics

See how Netdata's new Live Functions let you analyze slow queries, detect deadlocks, and monitor SNMP network interfaces directly from the Netdata dashboard, with a live demo.