Latency: guides, integrations and articles

Solutions

Gaming Infrastructure Monitoring & Observability

Keep your gaming platform fast and stable with real-time visibility, ML detection, and AI-powered root cause analysis for 99.9% uptime. Book a demo now!

Guides

Cassandra Operations Guides 4 pages

Open the Cassandra Operations Guides hub

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 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 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 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.

Ceph Operations Guides 3 pages

Open the Ceph Operations Guides hub

Ceph blocked ops: client I/O stuck behind a single slow OSD

Localize the single slow OSD blocking client writes, read the op pipeline stage, and decide disk vs network vs op queue.

Ceph BLUEFS_SPILLOVER: RocksDB metadata spilling onto the slow device

Diagnose and fix Ceph BLUEFS_SPILLOVER when BlueStore RocksDB metadata overflows the DB partition and tanks OSD commit latency.

Ceph slow requests (SLOW_OPS): operations blocked past osd_op_complaint_time

Diagnose and resolve Ceph SLOW_OPS warnings where operations exceed osd_op_complaint_time (default 30s) and stall in the OSD pipeline.

ClickHouse Operations Guides 3 pages

Open the ClickHouse Operations Guides hub

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 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 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.

CockroachDB Operations Guides 5 pages

Open the CockroachDB Operations Guides hub

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 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 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 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.

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.

Docker Operations Guides 1 page

Open the Docker Operations Guides hub

Docker CPU throttling: the hidden cause of container latency

Diagnose and fix Docker container latency caused by CFS CPU throttling, even when average CPU usage looks moderate.

Elasticsearch Operations Guides 1 page

Open the Elasticsearch Operations Guides hub

Elasticsearch expensive queries: leading wildcards, regex, deep pagination, and scripts

Find and fix Elasticsearch queries that burn CPU and heap. Covers leading wildcards, regex, deep pagination, scripts, and the diagnostic signals that expose them.

HAProxy Operations Guides 3 pages

Open the HAProxy Operations Guides hub

HAProxy 504 Gateway Timeout: timeout server and the backend timeout cascade

Why HAProxy emits 504 Gateway Timeout when timeout server fires, how the backend timeout cascade builds, and how to diagnose it with rtime, qcur, econ, and frontend vs backend 5xx.

HAProxy Idle_pct dropping: event-loop CPU saturation and the busy-polling trap

What HAProxy Idle_pct actually measures, how to diagnose event-loop CPU saturation when it drops, and why the metric is meaningless when busy-polling is enabled.

HAProxy monitoring checklist: the signals every production proxy needs

A production checklist of the HAProxy signals that matter, organized by monitoring maturity: liveness, backend health, saturation, latency, errors, TLS, and certificate expiry.

Kafka Operations Guides 3 pages

Open the Kafka Operations Guides hub

Kafka disk I/O latency high: await, LocalTimeMs, and the slow-disk broker

Diagnose elevated disk I/O latency on Kafka brokers using iostat await and LocalTimeMs. Distinguish disk degradation from page cache misses and transient load.

Kafka fetch request latency high: FetchConsumer vs FetchFollower and page cache misses

Diagnose elevated Kafka fetch request latency by distinguishing consumer fetches from replica fetches and identifying page cache misses as the root cause.

Kafka REQUEST_TIMED_OUT: produce requests that expire before replication completes

Diagnose and fix Kafka REQUEST_TIMED_OUT errors when acks=all produce requests expire waiting for replication, request queue backup, or slow disk.

Kubernetes Operations Guides 2 pages

Open the Kubernetes Operations Guides hub

Kubernetes API Server etcd Latency: How To Fix It

Detect elevated etcd latency in Kubernetes before it cascades into control plane saturation, 429 rejections, and cluster-wide write failures.

Kubernetes API Server Slow Or Unresponsive: Causes & Fixes

Diagnose and fix a slow or unresponsive Kubernetes API server. Covers etcd latency, admission webhooks, APF throttling, memory pressure, and re-list storms with concrete checks and fixes.

Microsoft SQL Server Operations Guides 3 pages

Open the Microsoft SQL Server Operations Guides hub

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 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 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.

MongoDB Operations Guides 9 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 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 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 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 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 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 1 page

Open the MySQL Operations Guides hub

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.

Network Monitoring Operations Guides 1 page

Open the Network Monitoring Operations Guides hub

Asymmetric routing: why your path and latency measurements lie

Diagnose asymmetric routing that hides reverse-path degradation behind healthy forward-path measurements.

NGINX Operations Guides 11 pages

Open the NGINX Operations Guides hub

NGINX $request_time vs $upstream_response_time: isolating where latency lives

How to interpret NGINX timing variables to distinguish backend latency from client-side and disk I/O delays.

nginx 499 status code: why clients close connections before the response

Diagnose nginx 499 errors where clients abandon requests before the server responds. Learn to distinguish slow upstreams from network drops and load-balancer noise.

NGINX 504 Gateway Time-Out: Causes & Fixes

Fix nginx 504 Gateway Timeout by isolating slow upstreams, tuning proxy_read_timeout, and distinguishing 504 from 502.

NGINX active connections climbing: reading, writing, waiting explained

Interpret NGINX stub_status Reading, Writing, and Waiting states to distinguish healthy keepalive reuse from slow clients, slow upstreams, and connection exhaustion.

NGINX Backend Cascade Failure: When Slow Upstreams Take Down Everything

Diagnose and fix the cascade failure where one slow upstream exhausts nginx worker connections, overloads healthy backends, and brings down your entire proxy tier.

nginx limiting requests, excess -- understanding limit_req rejections

How nginx's limit_req leaky bucket rate limiting works, why rejected requests return 503 by default, and how to interpret excess rejections in error logs.

NGINX Monitoring Checklist: The Signals Every Production Server Needs

A four-level monitoring maturity model for NGINX covering survival, operational, mature, and expert signals every production server needs.

NGINX proxy buffer spill to disk: proxy_buffers and temp file latency

Large upstream responses exceeding proxy_buffers spill to temporary files on disk, causing silent latency spikes with no error log entry.

NGINX slow requests: from access log to root cause

Triage elevated NGINX $request_time by isolating client-side delays, upstream latency, temp-file spill, and CPU saturation using access log variables and OS signals.

nginx upstream timed out (110: Connection timed out) while connecting/reading

Diagnose and fix nginx upstream timeout errors. Learn to distinguish connect, send, and read phases, interpret retry encoding in $upstream_response_time, and tune proxy_next_upstream without causing cascades.

nginx: a client request body is buffered to a temporary file — what it means

Understand why nginx buffers client request bodies to temporary files, how client_body_buffer_size controls the threshold, and when to tune or disable buffering for streaming uploads.

PostgreSQL Operations Guides 1 page

Open the PostgreSQL Operations Guides hub

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.

Redis Operations Guides 6 pages

Open the Redis Operations Guides hub

Redis big keys: finding the giant key that blocks the event loop

Diagnose and fix Redis latency caused by oversized keys and O(N) commands blocking the single-threaded event loop.

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 event loop blocked: when one slow command freezes everything

Diagnose and fix Redis event loop blocking caused by slow commands, Lua scripts, and large key operations.

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 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 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.

VMware vSphere Operations Guides 1 page

Open the VMware vSphere Operations Guides hub

vSphere datastore latency high: reading GAVG, DAVG, and KAVG

How to read vSphere's GAVG, DAVG, and KAVG counters to localize high datastore latency to the array, the VMkernel, or both.

Apache ZooKeeper Operations Guides 4 pages

Open the Apache ZooKeeper Operations Guides hub

ZooKeeper "fsync-ing the write ahead log took too long": the disk warning behind most write stalls

What the ZooKeeper fsync warning really means, why it is the most critical disk signal in any ensemble, and how to triage it before it costs you quorum.

ZooKeeper avg_latency hides write stalls: why the headline number lies

Why zk_avg_latency hides write stalls on read-heavy ensembles, and how to monitor zk_updatelatency and zk_readlatency separately to catch them.

ZooKeeper dataLogDir sharing a disk with snapshots: the #1 fsync-latency footgun

Why ZooKeeper fsync latency spikes when the transaction log shares a disk with snapshots, how to confirm it, and how to move the log to a dedicated device safely.

ZooKeeper monitoring checklist: the signals every production ensemble needs

A four-level maturity checklist for monitoring production ZooKeeper ensembles, from liveness and quorum to fsync latency, GC pauses, and data integrity signals.

Academy

Blue-Green And Canary Deployments With NGINX

Stop fearing your rollouts- Learn which deployment KPIs and alerts will make your NGINX-powered progressive delivery a success

Synthetic Checks: Definition, Examples & Benefits

A Guide to Synthetic Checks and How Netdata Helps You Monitor Service Healthg

How To Fix 504 Gateway Timeout Errors In NGINX

A Comprehensive Guide For DevOps & SRE Professionals

HTTP Endpoints Monitoring

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

Ping Monitoring

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

TCP endpoints Monitoring

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

TCP/UDP Endpoints Monitoring

Learn everything about monitoring & troubleshooting TCP/UDP Endpoints, what metrics are important to monitor and why, and how to monitor TCP/UDP Endpoints with Netdata.